Fix path tests on Windows

Author: snejus

test/test_library.py

@@ -925,10 +925,10 @@ def test_albuminfo_reflects_metadata(self):
 
     def test_albuminfo_stores_art(self):
         ai = self.lib.get_album(self.i)
-        ai.artpath = "/my/great/art"
+        ai.artpath = os.fsdecode(np("/my/great/art"))
         ai.store()
         new_ai = self.lib.get_album(self.i)
-        assert new_ai.artpath == b"/my/great/art"
+        assert new_ai.artpath == np("/my/great/art")
 
     def test_albuminfo_for_two_items_doesnt_duplicate_row(self):
         i2 = item(self.lib)

test/test_query.py

@@ -21,6 +21,7 @@
 
 import pytest
 
+from beets import util
 from beets.dbcore import types
 from beets.dbcore.query import (
     AndQuery,
@@ -278,6 +279,23 @@ class TestPathQuery:
     and path separator detection across different platforms.
     """
 
+    @staticmethod
+    def abs_query_path(path: str, trailing_sep: bool = False) -> str:
+        """Build a platform-correct absolute query path without normalizing it.
+
+        On Windows, leading-slash paths are drive-rooted but Python 3.13 no
+        longer treats them as absolute. Prefix the current drive so explicit
+        path queries stay absolute while preserving raw segments such as ``..``.
+        """
+        if os.path.__name__ == "ntpath" and path.startswith("/"):
+            drive, _ = os.path.splitdrive(os.fsdecode(util.normpath(os.sep)))
+            path = drive + path
+
+        path = path.replace("/", os.sep)
+        if trailing_sep:
+            path = os.path.join(path, "")
+        return path.replace("\\", "\\\\")
+
     @pytest.fixture(scope="class")
     def lib(self, helper):
         helper.add_item(path=b"/aaa/bb/c.mp3", title="path item")
@@ -290,24 +308,32 @@ def lib(self, helper):
         return helper.lib
 
     @pytest.mark.parametrize(
-        "q, expected_titles",
+        "path, expected_titles, trailing_sep",
         [
-            _p("path:/aaa/bb/c.mp3", ["path item"], id="exact-match"),
-            _p("path:/aaa", ["path item"], id="parent-dir-no-slash"),
-            _p("path:/aaa/", ["path item"], id="parent-dir-with-slash"),
-            _p("path:/aa", [], id="no-match-does-not-match-parent-dir"),
-            _p("path:/xyzzy/", [], id="no-match"),
-            _p("path:/b/", [], id="fragment-no-match"),
-            _p("path:/x/../aaa/bb", ["path item"], id="non-normalized"),
-            _p("path::c\\.mp3$", ["path item"], id="regex"),
-            _p("path:/c/_", ["with underscore"], id="underscore-escaped"),
-            _p("path:/c/%", ["with percent"], id="percent-escaped"),
-            _p("path:/c/\\\\x", ["with backslash"], id="backslash-escaped"),
+            _p("/aaa/bb/c.mp3", ["path item"], False, id="exact-match"),
+            _p("/aaa", ["path item"], False, id="parent-dir-no-slash"),
+            _p("/aaa", ["path item"], True, id="parent-dir-with-slash"),
+            _p("/aa", [], False, id="no-match-does-not-match-parent-dir"),
+            _p("/xyzzy", [], True, id="no-match"),
+            _p("/b", [], True, id="fragment-no-match"),
+            _p("/x/../aaa/bb", ["path item"], False, id="non-normalized"),
+            _p(r"c\.mp3$", ["path item"], False, id="regex"),
+            _p("/c/_", ["with underscore"], False, id="underscore-escaped"),
+            _p("/c/%", ["with percent"], False, id="percent-escaped"),
+            _p(r"/c/\x", ["with backslash"], False, id="backslash-escaped"),
         ],
     )
-    def test_explicit(self, monkeypatch, lib, q, expected_titles):
+    def test_explicit(
+        self, monkeypatch, lib, path, expected_titles, trailing_sep
+    ):
         """Test explicit path queries with different path specifications."""
         monkeypatch.setattr("beets.util.case_sensitive", lambda *_: True)
+        if path == r"c\.mp3$":
+            q = f"path::{path}"
+        elif path == r"/c/\x" and os.path.__name__ != "ntpath":
+            q = r"path:/c/\\x"
+        else:
+            q = f"path:{self.abs_query_path(path, trailing_sep=trailing_sep)}"
 
         assert {i.title for i in lib.items(q)} == set(expected_titles)
 
@@ -318,7 +344,6 @@ def test_absolute(self, lib, helper, query):
         item_path = helper.lib_path / "item.mp3"
         bytes_path = os.fsencode(item_path)
         helper.add_item(path=bytes_path, title="absolute item")
-        # Escape backslashes for Windows paths
         q = f"{query}{item_path}".replace("\\", "\\\\")
 
         assert {i.title for i in lib.items(q)} == {"absolute item"}
@@ -360,7 +385,7 @@ def test_case_sensitivity(
         self, lib, monkeypatch, case_sensitive, expected_titles
     ):
         """Test path matching with different case sensitivity settings."""
-        q = "path:/a/b/c2.mp3"
+        q = f"path:{self.abs_query_path('/a/b/c2.mp3')}"
         monkeypatch.setattr(
             "beets.util.case_sensitive", lambda *_: case_sensitive
         )

test/test_sort.py

@@ -14,16 +14,21 @@
 
 """Various tests for querying the library database."""
 
+import os
 from unittest.mock import patch
 
 import beets.library
-from beets import config, dbcore
+from beets import config, dbcore, util
 from beets.dbcore import types
 from beets.library import Album
 from beets.test import _common
 from beets.test.helper import BeetsTestCase
 
 
+def abs_test_path(path: str) -> str:
+    return os.fsdecode(util.normpath(path))
+
+
 # A test case class providing a library with some dummy data and some
 # assertions involving that data.
 class DummyDataTestCase(BeetsTestCase):
@@ -69,7 +74,7 @@ def setUp(self):
         items[0].flex2 = "Flex2-A"
         items[0].album_id = albums[0].id
         items[0].artist_sort = None
-        items[0].path = "/path0.mp3"
+        items[0].path = abs_test_path("/path0.mp3")
         items[0].track = 1
         items[1].title = "Baz qux"
         items[1].artist = "Two"
@@ -80,7 +85,7 @@ def setUp(self):
         items[1].flex2 = "Flex2-A"
         items[1].album_id = albums[0].id
         items[1].artist_sort = None
-        items[1].path = "/patH1.mp3"
+        items[1].path = abs_test_path("/patH1.mp3")
         items[1].track = 2
         items[2].title = "Beets 4 eva"
         items[2].artist = "Three"
@@ -91,7 +96,7 @@ def setUp(self):
         items[2].flex2 = "Flex1-B"
         items[2].album_id = albums[1].id
         items[2].artist_sort = None
-        items[2].path = "/paTH2.mp3"
+        items[2].path = abs_test_path("/paTH2.mp3")
         items[2].track = 3
         items[3].title = "Beets 4 eva"
         items[3].artist = "Three"
@@ -102,7 +107,7 @@ def setUp(self):
         items[3].flex2 = "Flex1-C"
         items[3].album_id = albums[2].id
         items[3].artist_sort = None
-        items[3].path = "/PATH3.mp3"
+        items[3].path = abs_test_path("/PATH3.mp3")
         items[3].track = 4
         for item in items:
             self.lib.add(item)
@@ -156,10 +161,10 @@ def test_sort_path_field(self):
         q = ""
         sort = dbcore.query.FixedFieldSort("path", True)
         results = self.lib.items(q, sort)
-        assert results[0]["path"] == b"/path0.mp3"
-        assert results[1]["path"] == b"/patH1.mp3"
-        assert results[2]["path"] == b"/paTH2.mp3"
-        assert results[3]["path"] == b"/PATH3.mp3"
+        assert results[0]["path"] == util.normpath("/path0.mp3")
+        assert results[1]["path"] == util.normpath("/patH1.mp3")
+        assert results[2]["path"] == util.normpath("/paTH2.mp3")
+        assert results[3]["path"] == util.normpath("/PATH3.mp3")
 
 
 class SortFlexFieldTest(DummyDataTestCase):