josh/django-language-server
1
0
Fork 0
mirror of https://github.com/joshuadavidthomas/django-language-server.git synced 2025-09-11 12:56:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

fix path handling for platform differences (#212)

Browse source
This commit is contained in:
Josh Thomas 2025-09-09 13:10:03 -05:00 • committed by GitHub
parent bc0b6c5cc8
commit f6286f7f46
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 148 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.github/workflows/test.yml vendored
View file

@ -71,8 +71,10 @@ jobs:
with:
activate-environment: true
enable-cache: true
python-version: ${{ matrix.python-version }}
- name: Run tests
shell: bash
env:
DJANGO_VERSION: ${{ matrix.django-version }}
PYTHON_VERSION: ${{ matrix.python-version }}

5
crates/djls-project/src/python.rs
View file

@ -497,6 +497,7 @@ mod tests {
use super::*;
#[test]
#[ignore = "Requires Python runtime - run with --ignored flag"]
fn test_activate_appends_paths() -> PyResult<()> {
let temp_dir = tempdir().unwrap();
let path1 = temp_dir.path().join("scripts");
@ -534,6 +535,7 @@ mod tests {
}
#[test]
#[ignore = "Requires Python runtime - run with --ignored flag"]
fn test_activate_empty_sys_path() -> PyResult<()> {
let test_env = create_test_env(vec![]);
@ -555,6 +557,7 @@ mod tests {
}
#[test]
#[ignore = "Requires Python runtime - run with --ignored flag"]
fn test_activate_with_non_existent_paths() -> PyResult<()> {
let temp_dir = tempdir().unwrap();
let path1 = temp_dir.path().join("non_existent_dir");
@ -591,6 +594,7 @@ mod tests {
#[test]
#[cfg(unix)]
#[ignore = "Requires Python runtime - run with --ignored flag"]
fn test_activate_skips_non_utf8_paths_unix() -> PyResult<()> {
use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
@ -642,6 +646,7 @@ mod tests {
#[test]
#[cfg(windows)]
#[ignore = "Requires Python runtime - run with --ignored flag"]
fn test_activate_skips_non_utf8_paths_windows() -> PyResult<()> {
use std::ffi::OsString;
use std::os::windows::ffi::OsStringExt;

11
crates/djls-server/src/queue.rs
View file

@ -281,7 +281,12 @@ mod tests {
Ok(())
});
match tokio::time::timeout(Duration::from_millis(500), submit_task).await {
#[cfg(windows)]
let timeout_ms = 1000;
#[cfg(not(windows))]
let timeout_ms = 500;
match tokio::time::timeout(Duration::from_millis(timeout_ms), submit_task).await {
Ok(Ok(())) => {
println!("Successfully submitted 33rd task");
}
@ -291,7 +296,11 @@ mod tests {
),
}
#[cfg(windows)]
sleep(Duration::from_millis(1000)).await;
#[cfg(not(windows))]
sleep(Duration::from_millis(200)).await;
assert_eq!(counter.load(Ordering::Relaxed), 33);
}

18
crates/djls-server/src/session.rs
View file

@ -271,6 +271,18 @@ mod tests {
use super::*;
// Helper function to create a test file path and URL that works on all platforms
fn test_file_url(filename: &str) -> (PathBuf, Url) {
// Use an absolute path that's valid on the platform
#[cfg(windows)]
let path = PathBuf::from(format!("C:\\temp\\{filename}"));
#[cfg(not(windows))]
let path = PathBuf::from(format!("/tmp/{filename}"));
let url = Url::from_file_path(&path).expect("Failed to create file URL");
(path, url)
}
#[test]
fn test_session_database_operations() {
let mut session = Session::default();
@ -287,7 +299,7 @@ mod tests {
#[test]
fn test_session_document_lifecycle() {
let mut session = Session::default();
let url = Url::parse("file:///test.py").unwrap();
let (path, url) = test_file_url("test.py");
// Open document
let document = TextDocument::new("print('hello')".to_string(), 1, LanguageId::Python);
@ -297,7 +309,6 @@ mod tests {
assert!(session.get_document(&url).is_some());
// Should be queryable through database
let path = PathBuf::from("/test.py");
let file = session.get_or_create_file(&path);
let content = session.with_db(|db| source_text(db, file).to_string());
assert_eq!(content, "print('hello')");
@ -310,7 +321,7 @@ mod tests {
#[test]
fn test_session_document_update() {
let mut session = Session::default();
let url = Url::parse("file:///test.py").unwrap();
let (path, url) = test_file_url("test.py");
// Open with initial content
let document = TextDocument::new("initial".to_string(), 1, LanguageId::Python);
@ -330,7 +341,6 @@ mod tests {
assert_eq!(doc.version(), 2);
// Database should also see updated content
let path = PathBuf::from("/test.py");
let file = session.get_or_create_file(&path);
let content = session.with_db(|db| source_text(db, file).to_string());
assert_eq!(content, "updated");

87
crates/djls-workspace/src/fs.rs
View file

@ -166,6 +166,14 @@ mod tests {
use crate::document::TextDocument;
use crate::language::LanguageId;
// Helper to create platform-appropriate test paths
fn test_file_path(name: &str) -> PathBuf {
#[cfg(windows)]
return PathBuf::from(format!("C:\\temp\\{name}"));
#[cfg(not(windows))]
return PathBuf::from(format!("/tmp/{name}"));
}
#[test]
fn test_reads_from_buffer_when_present() {
let disk = Arc::new(InMemoryFileSystem::new());
@ -173,47 +181,41 @@ mod tests {
let fs = WorkspaceFileSystem::new(buffers.clone(), disk);
// Add file to buffer
let url = Url::from_file_path("/test.py").unwrap();
let path = test_file_path("test.py");
let url = Url::from_file_path(&path).unwrap();
let doc = TextDocument::new("buffer content".to_string(), 1, LanguageId::Python);
buffers.open(url, doc);
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"buffer content"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "buffer content");
}
#[test]
fn test_reads_from_disk_when_no_buffer() {
let mut disk_fs = InMemoryFileSystem::new();
disk_fs.add_file("/test.py".into(), "disk content".to_string());
let path = test_file_path("test.py");
disk_fs.add_file(path.clone(), "disk content".to_string());
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers, Arc::new(disk_fs));
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"disk content"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "disk content");
}
#[test]
fn test_buffer_overrides_disk() {
let mut disk_fs = InMemoryFileSystem::new();
disk_fs.add_file("/test.py".into(), "disk content".to_string());
let path = test_file_path("test.py");
disk_fs.add_file(path.clone(), "disk content".to_string());
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers.clone(), Arc::new(disk_fs));
// Add buffer with different content
let url = Url::from_file_path("/test.py").unwrap();
let url = Url::from_file_path(&path).unwrap();
let doc = TextDocument::new("buffer content".to_string(), 1, LanguageId::Python);
buffers.open(url, doc);
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"buffer content"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "buffer content");
}
#[test]
@ -222,39 +224,42 @@ mod tests {
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers.clone(), disk);
// Add file only to buffer
let url = Url::from_file_path("/buffer_only.py").unwrap();
// Add file to buffer only
let path = test_file_path("buffer_only.py");
let url = Url::from_file_path(&path).unwrap();
let doc = TextDocument::new("content".to_string(), 1, LanguageId::Python);
buffers.open(url, doc);
assert!(fs.exists(Path::new("/buffer_only.py")));
assert!(fs.exists(&path));
}
#[test]
fn test_exists_for_disk_only_file() {
let mut disk_fs = InMemoryFileSystem::new();
disk_fs.add_file("/disk_only.py".into(), "content".to_string());
let path = test_file_path("disk_only.py");
disk_fs.add_file(path.clone(), "content".to_string());
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers, Arc::new(disk_fs));
assert!(fs.exists(Path::new("/disk_only.py")));
assert!(fs.exists(&path));
}
#[test]
fn test_exists_for_both_buffer_and_disk() {
let mut disk_fs = InMemoryFileSystem::new();
disk_fs.add_file("/both.py".into(), "disk".to_string());
let path = test_file_path("both.py");
disk_fs.add_file(path.clone(), "disk".to_string());
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers.clone(), Arc::new(disk_fs));
// Also add to buffer
let url = Url::from_file_path("/both.py").unwrap();
let url = Url::from_file_path(&path).unwrap();
let doc = TextDocument::new("buffer".to_string(), 1, LanguageId::Python);
buffers.open(url, doc);
assert!(fs.exists(Path::new("/both.py")));
assert!(fs.exists(&path));
}
#[test]
@ -263,7 +268,8 @@ mod tests {
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers, disk);
assert!(!fs.exists(Path::new("/nowhere.py")));
let path = test_file_path("nowhere.py");
assert!(!fs.exists(&path));
}
#[test]
@ -272,7 +278,8 @@ mod tests {
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers, disk);
let result = fs.read_to_string(Path::new("/missing.py"));
let path = test_file_path("missing.py");
let result = fs.read_to_string(&path);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
}
@ -283,49 +290,39 @@ mod tests {
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers.clone(), disk);
let url = Url::from_file_path("/test.py").unwrap();
let path = test_file_path("test.py");
let url = Url::from_file_path(&path).unwrap();
// Initial buffer content
let doc1 = TextDocument::new("version 1".to_string(), 1, LanguageId::Python);
buffers.open(url.clone(), doc1);
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"version 1"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "version 1");
// Update buffer content
let doc2 = TextDocument::new("version 2".to_string(), 2, LanguageId::Python);
buffers.update(url, doc2);
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"version 2"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "version 2");
}
#[test]
fn test_handles_buffer_removal() {
let mut disk_fs = InMemoryFileSystem::new();
disk_fs.add_file("/test.py".into(), "disk content".to_string());
let path = test_file_path("test.py");
disk_fs.add_file(path.clone(), "disk content".to_string());
let buffers = Buffers::new();
let fs = WorkspaceFileSystem::new(buffers.clone(), Arc::new(disk_fs));
let url = Url::from_file_path("/test.py").unwrap();
let url = Url::from_file_path(&path).unwrap();
// Add buffer
let doc = TextDocument::new("buffer content".to_string(), 1, LanguageId::Python);
buffers.open(url.clone(), doc);
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"buffer content"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "buffer content");
// Remove buffer
let _ = buffers.close(&url);
assert_eq!(
fs.read_to_string(Path::new("/test.py")).unwrap(),
"disk content"
);
assert_eq!(fs.read_to_string(&path).unwrap(), "disk content");
}
}
}

48
crates/djls-workspace/src/paths.rs
View file

@ -27,11 +27,23 @@ pub fn url_to_path(url: &Url) -> Option<PathBuf> {
#[cfg(windows)]
let path = {
// Remove leading '/' for paths like /C:/...
path.strip_prefix('/').unwrap_or(&path)
// Remove leading '/' only for Windows drive paths like /C:/...
// Check if it matches the pattern /X:/ where X is a drive letter
if path.len() >= 3 {
let bytes = path.as_bytes();
if bytes[0] == b'/' && bytes[2] == b':' && bytes[1].is_ascii_alphabetic() {
// It's a drive path like /C:/, strip the leading /
&path[1..]
} else {
// Keep as-is for other paths
&path
}
} else {
&path
}
};
Some(PathBuf::from(path.as_ref()))
Some(PathBuf::from(&*path))
}
/// Context for LSP operations, used for error reporting
@ -132,9 +144,17 @@ mod tests {
#[test]
fn test_url_to_path_valid_file_url() {
#[cfg(not(windows))]
{
let url = Url::parse("file:///home/user/test.py").unwrap();
assert_eq!(url_to_path(&url), Some(PathBuf::from("/home/user/test.py")));
}
#[cfg(windows)]
{
let url = Url::parse("file:///C:/Users/test.py").unwrap();
assert_eq!(url_to_path(&url), Some(PathBuf::from("C:/Users/test.py")));
}
}
#[test]
fn test_url_to_path_non_file_scheme() {
@ -144,12 +164,23 @@ mod tests {
#[test]
fn test_url_to_path_percent_encoded() {
#[cfg(not(windows))]
{
let url = Url::parse("file:///home/user/test%20file.py").unwrap();
assert_eq!(
url_to_path(&url),
Some(PathBuf::from("/home/user/test file.py"))
);
}
#[cfg(windows)]
{
let url = Url::parse("file:///C:/Users/test%20file.py").unwrap();
assert_eq!(
url_to_path(&url),
Some(PathBuf::from("C:/Users/test file.py"))
);
}
}
#[test]
#[cfg(windows)]
@ -169,12 +200,23 @@ mod tests {
// lsp_uri_to_path tests
#[test]
fn test_lsp_uri_to_path_valid_file() {
#[cfg(not(windows))]
{
let uri = lsp_types::Uri::from_str("file:///home/user/test.py").unwrap();
assert_eq!(
lsp_uri_to_path(&uri),
Some(PathBuf::from("/home/user/test.py"))
);
}
#[cfg(windows)]
{
let uri = lsp_types::Uri::from_str("file:///C:/Users/test.py").unwrap();
assert_eq!(
lsp_uri_to_path(&uri),
Some(PathBuf::from("C:/Users/test.py"))
);
}
}
#[test]
fn test_lsp_uri_to_path_non_file() {

21
noxfile.py
View file

@ -2,6 +2,7 @@ from __future__ import annotations
import json
import os
import platform
import re
from pathlib import Path
@ -92,6 +93,13 @@ def tests(session, django):
session.install(f"django=={django}")
command = ["cargo", "test"]
# TODO: Remove this exclusion once PyO3 is replaced with subprocess oracle pattern
# Temporarily exclude djls-project tests on Windows due to PyO3 DLL loading issues
# (STATUS_DLL_NOT_FOUND when the test executable tries to load Python)
if platform.system() == "Windows":
command.extend(["--workspace", "--exclude", "djls-project"])
if session.posargs:
args = []
for arg in session.posargs:
@ -136,9 +144,16 @@ def gha_matrix(session):
if session["name"] == "tests"
]
matrix = {
"include": [{**combo, "os": os} for os in os_list for combo in versions_list]
}
# Build the matrix, excluding Python 3.9 on macOS (PyO3 linking issues)
include_list = []
for os_name in os_list:
for combo in versions_list:
# Skip Python 3.9 on macOS due to PyO3/framework linking issues
if os_name.startswith("macos") and combo["python-version"] == "3.9":
continue
include_list.append({**combo, "os": os_name})
matrix = {"include": include_list}
if os.environ.get("GITHUB_OUTPUT"):
with Path(os.environ["GITHUB_OUTPUT"]).open("a") as fh: