Add additional tests for --uploaded-prior-to

notatallshaw · notatallshaw · commit 7a79049cf377 · 2025-11-07T23:28:11.000-05:00
diff --git a/tests/functional/test_uploaded_prior_to.py b/tests/functional/test_uploaded_prior_to.py
@@ -0,0 +1,140 @@
+"""Tests for pip install --uploaded-prior-to."""
+
+from __future__ import annotations
+
+import pytest
+
+from tests.lib import PipTestEnvironment, TestData
+from tests.lib.server import (
+    file_response,
+    make_mock_server,
+    package_page,
+    server_running,
+)
+
+
+class TestUploadedPriorTo:
+    """Test --uploaded-prior-to functionality."""
+
+    def test_uploaded_prior_to_invalid_date(
+        self, script: PipTestEnvironment, data: TestData
+    ) -> None:
+        """Test that invalid date format is rejected."""
+        result = script.pip_install_local(
+            "--uploaded-prior-to=invalid-date", "simple", expect_error=True
+        )
+        assert "invalid" in result.stderr.lower() or "error" in result.stderr.lower()
+
+    def test_uploaded_prior_to_file_index_no_upload_time(
+        self, script: PipTestEnvironment, data: TestData
+    ) -> None:
+        """Test that file:// indexes are exempt from upload-time filtering."""
+        result = script.pip(
+            "install",
+            "--index-url",
+            data.index_url("simple"),
+            "--uploaded-prior-to=2100-01-01T00:00:00",
+            "simple",
+            expect_error=False,
+        )
+        assert "Successfully installed simple" in result.stdout
+
+    def test_uploaded_prior_to_http_index_no_upload_time(
+        self, script: PipTestEnvironment, data: TestData
+    ) -> None:
+        """Test that HTTP index without upload-time causes immediate error."""
+        server = make_mock_server()
+        simple_package = data.packages / "simple-1.0.tar.gz"
+        server.mock.side_effect = [
+            package_page({"simple-1.0.tar.gz": "/files/simple-1.0.tar.gz"}),
+            file_response(simple_package),
+        ]
+
+        with server_running(server):
+            result = script.pip(
+                "install",
+                "--index-url",
+                f"http://{server.host}:{server.port}",
+                "--uploaded-prior-to=2100-01-01T00:00:00",
+                "simple",
+                expect_error=True,
+            )
+
+        assert "does not provide upload-time metadata" in result.stderr
+        assert "--uploaded-prior-to" in result.stderr or "Cannot use" in result.stderr
+
+    @pytest.mark.network
+    def test_uploaded_prior_to_with_real_pypi(self, script: PipTestEnvironment) -> None:
+        """Test filtering against real PyPI with upload-time metadata."""
+        # Test with old cutoff date - should find no matching versions
+        result = script.pip(
+            "install",
+            "--dry-run",
+            "--no-deps",
+            "--uploaded-prior-to=2010-01-01T00:00:00",
+            "requests==2.0.0",
+            expect_error=True,
+        )
+        assert "Could not find a version that satisfies" in result.stderr
+
+        # Test with future cutoff date - should find the package
+        result = script.pip(
+            "install",
+            "--dry-run",
+            "--no-deps",
+            "--uploaded-prior-to=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_uploaded_prior_to_date_formats(self, script: PipTestEnvironment) -> None:
+        """Test various date format strings are accepted."""
+        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",
+                "--no-deps",
+                f"--uploaded-prior-to={date_format}",
+                "requests==2.0.0",
+                expect_error=False,
+            )
+            assert "Would install requests-2.0.0" in result.stdout
+
+    def test_uploaded_prior_to_allows_local_files(
+        self, script: PipTestEnvironment, data: TestData
+    ) -> None:
+        """Test that local file installs bypass upload-time filtering."""
+        simple_wheel = data.packages / "simplewheel-1.0-py2.py3-none-any.whl"
+
+        result = script.pip(
+            "install",
+            "--no-index",
+            "--uploaded-prior-to=2000-01-01T00:00:00",
+            str(simple_wheel),
+            expect_error=False,
+        )
+        assert "Successfully installed simplewheel-1.0" in result.stdout
+
+    def test_uploaded_prior_to_allows_find_links(
+        self, script: PipTestEnvironment, data: TestData
+    ) -> None:
+        """Test that --find-links bypasses upload-time filtering."""
+        result = script.pip(
+            "install",
+            "--no-index",
+            "--find-links",
+            data.find_links,
+            "--uploaded-prior-to=2000-01-01T00:00:00",
+            "simple==1.0",
+            expect_error=False,
+        )
+        assert "Successfully installed simple-1.0" in result.stdout
diff --git a/tests/lib/__init__.py b/tests/lib/__init__.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 import json
 import os
 import pathlib
@@ -104,6 +105,7 @@ def make_test_finder(
     allow_all_prereleases: bool = False,
     session: PipSession | None = None,
     target_python: TargetPython | None = None,
+    uploaded_prior_to: datetime.datetime | None = None,
 ) -> PackageFinder:
     """
     Create a PackageFinder for testing purposes.
@@ -122,6 +124,7 @@ def make_test_finder(
         link_collector=link_collector,
         selection_prefs=selection_prefs,
         target_python=target_python,
+        uploaded_prior_to=uploaded_prior_to,
     )
 
 
diff --git a/tests/unit/test_cmdoptions.py b/tests/unit/test_cmdoptions.py
@@ -1,12 +1,17 @@
 from __future__ import annotations
 
+import datetime
 import os
+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_uploaded_prior_to,
+)
 from pip._internal.cli.main_parser import identify_python_interpreter
 
 
@@ -51,3 +56,122 @@ 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_datetime",
+    [
+        (
+            "2023-01-01T00:00:00+00:00",
+            datetime.datetime(2023, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc),
+        ),
+        (
+            "2023-01-01T12:00:00-05:00",
+            datetime.datetime(
+                *(2023, 1, 1, 12, 0, 0),
+                tzinfo=datetime.timezone(datetime.timedelta(hours=-5)),
+            ),
+        ),
+    ],
+)
+def test_handle_uploaded_prior_to_with_timezone(
+    value: str, expected_datetime: datetime.datetime
+) -> None:
+    """Test that timezone-aware ISO 8601 date strings are parsed correctly."""
+    option = Option("--uploaded-prior-to", dest="uploaded_prior_to")
+    opt = "--uploaded-prior-to"
+    parser = OptionParser()
+    parser.values = Values()
+
+    _handle_uploaded_prior_to(option, opt, value, parser)
+
+    result = parser.values.uploaded_prior_to
+    assert isinstance(result, datetime.datetime)
+    assert result == expected_datetime
+
+
+@pytest.mark.parametrize(
+    "value, expected_date_time",
+    [
+        # Test basic ISO 8601 formats (timezone-naive, will get local 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_uploaded_prior_to_naive_dates(
+    value: str, expected_date_time: tuple[int, int, int, int, int, int]
+) -> None:
+    """Test that timezone-naive ISO 8601 date strings get local timezone applied."""
+    option = Option("--uploaded-prior-to", dest="uploaded_prior_to")
+    opt = "--uploaded-prior-to"
+    parser = OptionParser()
+    parser.values = Values()
+
+    _handle_uploaded_prior_to(option, opt, value, parser)
+
+    result = parser.values.uploaded_prior_to
+    assert isinstance(result, datetime.datetime)
+
+    # Check that the date/time components match
+    assert result.timetuple()[:6] == expected_date_time
+
+    # Check that local timezone was applied (result should not be timezone-naive)
+    assert result.tzinfo is not None
+
+    # Verify it's equivalent to what .astimezone() produces on a naive datetime
+    naive_dt = datetime.datetime(*expected_date_time)
+    expected_with_local_tz = naive_dt.astimezone()
+    assert result == expected_with_local_tz
+
+
+@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_uploaded_prior_to_invalid_dates(invalid_value: str) -> None:
+    """Test that invalid date strings raise SystemExit via raise_option_error."""
+    option = Option("--uploaded-prior-to", dest="uploaded_prior_to")
+    opt = "--uploaded-prior-to"
+    parser = OptionParser()
+    parser.values = Values()
+
+    with pytest.raises(SystemExit):
+        _handle_uploaded_prior_to(option, opt, invalid_value, parser)
+
+
+def test_handle_uploaded_prior_to_naive() -> None:
+    """
+    Test that a naive datetime is interpreted as local time.
+    """
+    option = Option("--uploaded-prior-to", dest="uploaded_prior_to")
+    opt = "--uploaded-prior-to"
+    parser = OptionParser()
+    parser.values = Values()
+
+    # Parse a naive datetime
+    naive_input = "2023-06-15T14:30:00"
+    _handle_uploaded_prior_to(option, opt, naive_input, parser)
+    result = parser.values.uploaded_prior_to
+
+    assert result.hour == 14, (
+        f"Expected hour=14 (from input), got hour={result.hour}. "
+        "This suggests the naive datetime was incorrectly interpreted as UTC "
+        "and converted to local timezone."
+    )
+    assert result.minute == 30
+    assert result.year == 2023
+    assert result.month == 6
+    assert result.day == 15
+
+    # Verify by creating the same datetime with explicit local timezone
+    local_tz = datetime.datetime.now().astimezone().tzinfo
+    expected = datetime.datetime(2023, 6, 15, 14, 30, 0, tzinfo=local_tz)
+    assert result == expected
diff --git a/tests/unit/test_finder.py b/tests/unit/test_finder.py
@@ -1,3 +1,4 @@
+import datetime
 import logging
 from collections.abc import Iterable
 from unittest.mock import Mock, patch
@@ -575,3 +576,40 @@ 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 TestPackageFinderUploadedPriorTo:
+    """Test PackageFinder integration with uploaded_prior_to functionality.
+
+    Only effective with indexes that provide upload-time metadata.
+    """
+
+    def test_package_finder_create_with_uploaded_prior_to(self) -> None:
+        """Test that PackageFinder.create() accepts uploaded_prior_to parameter."""
+        uploaded_prior_to = datetime.datetime(
+            2023, 6, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+
+        finder = make_test_finder(uploaded_prior_to=uploaded_prior_to)
+
+        assert finder._uploaded_prior_to == uploaded_prior_to
+
+    def test_package_finder_make_link_evaluator_with_uploaded_prior_to(self) -> None:
+        """Test that PackageFinder creates LinkEvaluator with uploaded_prior_to."""
+        uploaded_prior_to = datetime.datetime(
+            2023, 6, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+        )
+
+        finder = make_test_finder(uploaded_prior_to=uploaded_prior_to)
+
+        link_evaluator = finder.make_link_evaluator("test-package")
+        assert link_evaluator._uploaded_prior_to == uploaded_prior_to
+
+    def test_package_finder_uploaded_prior_to_none(self) -> None:
+        """Test that PackageFinder works correctly when uploaded_prior_to is None."""
+        finder = make_test_finder(uploaded_prior_to=None)
+
+        assert finder._uploaded_prior_to is None
+
+        link_evaluator = finder.make_link_evaluator("test-package")
+        assert link_evaluator._uploaded_prior_to is None
diff --git a/tests/unit/test_index.py b/tests/unit/test_index.py
