pytest-language-server 0.5.2__tar.gz → 0.6.0__tar.gz

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/.github/workflows/release.yml

@@ -244,6 +244,8 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y gcc-aarch64-linux-gnu
       - name: Build binary
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
         run: |
           cargo build --release --target ${{ matrix.target }}
       - name: Rename binary (Unix)
@@ -284,16 +286,16 @@ jobs:
           ls -lh
       - name: Install dependencies
         run: |
-          cd vscode-extension
+          cd extensions/vscode-extension
           npm install
           npm install -g @vscode/vsce
       - name: Package extension
         run: |
-          cd vscode-extension
+          cd extensions/vscode-extension
           vsce package
       - name: Publish to VSCode Marketplace
         run: |
-          cd vscode-extension
+          cd extensions/vscode-extension
           vsce publish -p ${{ secrets.VSCE_TOKEN }}
 
   publish-intellij:
@@ -340,44 +342,13 @@ jobs:
   publish-zed:
     name: Publish Zed extension
     runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    needs: [build-binaries]
+    # Disabled until the extension is ready to be published
+    if: false
     steps:
-      - uses: actions/checkout@v4
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: wasm32-wasip1
-      - name: Download all binaries
-        uses: actions/download-artifact@v6
-        with:
-          pattern: binary-*
-          path: extensions/zed-extension/bin
-      - name: Flatten binaries
-        run: |
-          cd extensions/zed-extension/bin
-          find . -type f -name "pytest-language-server*" -exec mv {} . \;
-          find . -type d -empty -delete
-          chmod +x pytest-language-server-* || true
-          ls -lh
-      - name: Build Zed extension
-        run: |
-          cd zed-extension
-          cargo build --release --target wasm32-wasip1
-      - name: Package extension
-        run: |
-          cd zed-extension
-          mkdir -p dist
-          cp target/wasm32-wasip1/release/pytest_language_server.wasm dist/extension.wasm
-          cp -r bin dist/
-          cp extension.toml dist/
-      - name: Publish to Zed Extensions
-        run: |
-          cd zed-extension
-          # Note: Zed extension publishing requires manual submission or API key
-          # For now, just upload the packaged extension to GitHub releases
-          tar -czf ../pytest-language-server-zed-extension.tar.gz -C dist .
-      - name: Upload Zed extension to release
-        uses: softprops/action-gh-release@v2
+      - uses: huacnlee/zed-extension-action@v1
         with:
-          files: pytest-language-server-zed-extension.tar.gz
+          extension-name: pytest-language-server
+          extension-path: extensions/zed-extension
+          push-to: bellini666/extensions
+        env:
+          COMMITTER_TOKEN: ${{ secrets.COMMITTER_TOKEN }}

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/Cargo.lock

@@ -753,7 +753,7 @@ dependencies = [
 
 [[package]]
 name = "pytest-language-server"
-version = "0.5.2"
+version = "0.6.0"
 dependencies = [
  "dashmap 6.1.0",
  "rustpython-parser",

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pytest-language-server"
-version = "0.5.2"
+version = "0.6.0"
 edition = "2021"
 rust-version = "1.83"
 authors = ["Thiago Bellini Ribeiro <hackedbellini@gmail.com>"]

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/EXTENSION_PUBLISHING.md

@@ -89,17 +89,44 @@ cd extensions/intellij-plugin
 
 ### 3. Zed Extension Setup
 
-**Note**: Zed currently uses a manual extension publishing process or requires submitting to their repository.
+**Automated Publishing (via GitHub Action):**
 
-**For Manual Distribution:**
-The CI automatically packages the Zed extension as `pytest-language-server-zed-extension.tar.gz` and uploads it to GitHub releases.
+Zed extensions are published by creating PRs to the official Zed extensions repository. This is automated using the `huacnlee/zed-extension-action` GitHub Action.
 
-**For Official Zed Extension Directory:**
-1. Fork https://github.com/zed-industries/extensions
-2. Add extension to `extensions/` directory
-3. Submit PR to Zed extensions repo
+**Setup Steps:**
 
-The extension will still be bundled with binaries in your GitHub releases for users to install manually.
+1. **Fork the Zed Extensions Repo:**
+   ```bash
+   # Go to https://github.com/zed-industries/extensions
+   # Click "Fork" (fork to your personal account, not an organization)
+   ```
+
+2. **Add Your Extension to Your Fork:**
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/extensions
+   cd extensions
+   git submodule add https://github.com/bellini666/pytest-language-server.git extensions/pytest-language-server
+   ```
+
+3. **Add Entry to extensions.toml:**
+   ```toml
+   [pytest-language-server]
+   submodule = "extensions/pytest-language-server"
+   path = "extensions/zed-extension"
+   version = "0.5.2"
+   ```
+
+4. **Create Initial PR:**
+   Submit the initial PR to zed-industries/extensions manually.
+
+5. **Automated Updates:**
+   After the initial setup, the GitHub Action automatically creates PRs to update your extension when you create a new release tag.
+
+**How It Works:**
+- When you push a new version tag (e.g., `v0.6.0`), the `publish-zed` job runs
+- It uses your `COMMITTER_TOKEN` to create a PR on your fork of zed-industries/extensions
+- The PR updates the submodule commit and version in `extensions.toml`
+- You review and merge the PR to your fork, then submit to zed-industries/extensions
 
 ### 4. GitHub Secrets Configuration
 
@@ -109,8 +136,17 @@ Add these secrets to your GitHub repository (Settings → Secrets and variables
 VSCE_TOKEN=<your-vscode-marketplace-token>
 JETBRAINS_TOKEN=<your-jetbrains-marketplace-token>
 CARGO_REGISTRY_TOKEN=<your-crates-io-token>
+COMMITTER_TOKEN=<your-github-pat-with-repo-and-workflow-scopes>
 ```
 
+**COMMITTER_TOKEN Setup (Required for Zed Extension):**
+1. Go to https://github.com/settings/tokens/new
+2. Create a **Classic** Personal Access Token with these scopes:
+   - `repo` (Full control of private repositories)
+   - `workflow` (Update GitHub Action workflows)
+3. Copy the token and add it as `COMMITTER_TOKEN` secret
+4. This token allows the Zed extension action to create PRs to your fork of zed-industries/extensions
+
 **Optional IntelliJ Plugin Signing (for paid plugins):**
 ```
 CERTIFICATE_CHAIN=<your-certificate-chain>
@@ -277,6 +313,10 @@ If versions get out of sync:
 - [ ] Create JetBrains plugin listing
 - [ ] Generate JetBrains token
 - [ ] Add JETBRAINS_TOKEN to GitHub secrets
+- [ ] Fork zed-industries/extensions repository
+- [ ] Generate GitHub PAT with repo & workflow scopes
+- [ ] Add COMMITTER_TOKEN to GitHub secrets
+- [ ] Add CARGO_REGISTRY_TOKEN to GitHub secrets
 - [ ] Test VSCode extension locally
 - [ ] Test IntelliJ plugin locally
 - [ ] Test Zed extension locally

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-language-server
-Version: 0.5.2
+Version: 0.6.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -47,7 +47,7 @@ A blazingly fast Language Server Protocol (LSP) implementation for pytest, built
 
 ![pytest-language-server demo](demo.gif)
 
-*Showcasing go-to-definition, find-references, hover documentation, and code actions. Demo also vibed into existence.* ✨
+*Showcasing go-to-definition, code completion, hover documentation, and code actions. Demo also vibed into existence.* ✨
 
 ## Features
 
@@ -58,6 +58,15 @@ Jump directly to fixture definitions from anywhere they're used:
 - Third-party fixtures from pytest plugins (pytest-mock, pytest-asyncio, etc.)
 - Respects pytest's fixture shadowing/priority rules
 
+### ✨ Code Completion
+Smart auto-completion for pytest fixtures:
+- **Context-aware**: Only triggers inside test functions and fixture functions
+- **Hierarchy-respecting**: Suggests fixtures based on pytest's priority rules (same file > conftest.py > third-party)
+- **Rich information**: Shows fixture source file and docstring
+- **No duplicates**: Automatically filters out shadowed fixtures
+- **Works everywhere**: Completions available in both function parameters and function bodies
+- Supports both sync and async functions
+
 ### 🔍 Find References
 Find all usages of a fixture across your entire test suite:
 - Works from fixture definitions or usage sites

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/README.md

@@ -21,7 +21,7 @@ A blazingly fast Language Server Protocol (LSP) implementation for pytest, built
 
 ![pytest-language-server demo](demo.gif)
 
-*Showcasing go-to-definition, find-references, hover documentation, and code actions. Demo also vibed into existence.* ✨
+*Showcasing go-to-definition, code completion, hover documentation, and code actions. Demo also vibed into existence.* ✨
 
 ## Features
 
@@ -32,6 +32,15 @@ Jump directly to fixture definitions from anywhere they're used:
 - Third-party fixtures from pytest plugins (pytest-mock, pytest-asyncio, etc.)
 - Respects pytest's fixture shadowing/priority rules
 
+### ✨ Code Completion
+Smart auto-completion for pytest fixtures:
+- **Context-aware**: Only triggers inside test functions and fixture functions
+- **Hierarchy-respecting**: Suggests fixtures based on pytest's priority rules (same file > conftest.py > third-party)
+- **Rich information**: Shows fixture source file and docstring
+- **No duplicates**: Automatically filters out shadowed fixtures
+- **Works everywhere**: Completions available in both function parameters and function bodies
+- Supports both sync and async functions
+
 ### 🔍 Find References
 Find all usages of a fixture across your entire test suite:
 - Works from fixture definitions or usage sites

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/demo.tape

@@ -24,9 +24,9 @@ Type "cd /Users/bellini/dev/pytest-language-server/tests/test_project" Enter
 Show
 
 # Title
-Type 'echo "pytest-language-server Demo"' Enter
+Type 'echo "🐍 pytest-language-server Demo ⚡"' Enter
 Sleep 1.5s
-Type 'echo "1. Hover Documentation"' Enter
+Type 'echo "📖 1. Hover Documentation & Go to Definition"' Enter
 Sleep 1.5s
 
 Type "nvim test_example.py" Enter
@@ -36,34 +36,62 @@ Hide
 Type ":set nu" Enter
 Show
 
+# Hover on sample_fixture
 Type "ggf(w"
 Sleep 1s
 Type "K"
 Sleep 3.5s
+
+# Close hover popup explicitly
 Escape
+Sleep 500ms
+
+# Go to definition on same fixture
+Type "gd"
+Sleep 2.5s
+Ctrl+O
 
 Type "ZQ"
 Sleep 300ms
 
-Type 'echo "2. Go to Definition"' Enter
+Type 'echo "✨ 2. Code Completion"' Enter
 Sleep 1.5s
 
 Type "nvim test_example.py" Enter
-Sleep 2s
+Sleep 2.5s
 
 Hide
 Type ":set nu" Enter
 Show
 
-Type "ggf(w"
-Type "gd"
-Sleep 2.5s
+# Navigate to first test function and go to end of parameters
+Type "gg"
+Sleep 300ms
+Type "f)"
+Sleep 300ms
+Type "i, "
+Sleep 500ms
+
+# Trigger completion
+Ctrl+X
 Ctrl+O
+Sleep 2.5s
 
-Type "ZQ"
+# Navigate down in completion menu
+Down
+Sleep 500ms
+Down
+Sleep 500ms
+Enter
+Sleep 1.5s
+
+# Exit without saving
+Escape
+Sleep 300ms
+Type ":q!" Enter
 Sleep 300ms
 
-Type 'echo "3. Code Actions"' Enter
+Type 'echo "🔧 3. Code Actions (Quick Fixes)"' Enter
 Sleep 1.5s
 
 Type "nvim test_undeclared_example.py" Enter
@@ -86,6 +114,7 @@ Type ":9" Enter
 Sleep 2s
 
 Type "ZQ"
+Sleep 300ms
 
-Type 'echo "github.com/bellini666/pytest-language-server"' Enter
+Type 'echo "✨ github.com/bellini666/pytest-language-server ✨"' Enter
 Sleep 2s

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/extensions/intellij-plugin/build.sh

@@ -2,7 +2,10 @@
 # Simple build script for IntelliJ plugin without Gradle
 set -e
 
-echo "Building pytest-language-server IntelliJ plugin..."
+# Extract version from plugin.xml
+VERSION=$(grep -o '<version>[^<]*</version>' src/main/resources/META-INF/plugin.xml | sed 's/<version>\(.*\)<\/version>/\1/')
+
+echo "Building pytest-language-server IntelliJ plugin v${VERSION}..."
 
 # Clean previous builds
 rm -rf build
@@ -15,6 +18,13 @@ echo "Copying resources..."
 cp src/main/resources/META-INF/plugin.xml build/META-INF/
 cp src/main/resources/META-INF/pluginIcon.png build/META-INF/
 
+# Copy bundled binaries if they exist
+if [ -d "src/main/resources/bin" ]; then
+  echo "Copying bundled binaries..."
+  mkdir -p build/bin
+  cp -r src/main/resources/bin/* build/bin/
+fi
+
 # Compile Kotlin files (simple compilation without dependencies for now)
 # Note: For a real LSP plugin, you'd need proper IntelliJ SDK compilation
 # For CI, we'll just package the source files which JetBrains can compile
@@ -24,7 +34,11 @@ cp -r src/main/java/com/github/bellini666/pytestlsp/*.kt build/classes/com/githu
 # Create JAR
 echo "Creating plugin JAR..."
 cd build
-jar cf ../pytest-language-server.jar META-INF/ classes/
+if [ -d "bin" ]; then
+  jar cf ../pytest-language-server.jar META-INF/ classes/ bin/
+else
+  jar cf ../pytest-language-server.jar META-INF/ classes/
+fi
 
 # Create distribution ZIP
 cd ..
@@ -33,7 +47,7 @@ cp pytest-language-server.jar dist/
 cd dist
 mkdir -p pytest-language-server/lib
 mv pytest-language-server.jar pytest-language-server/lib/
-zip -r pytest-language-server-0.5.1.zip pytest-language-server/
+zip -r pytest-language-server-${VERSION}.zip pytest-language-server/
 
-echo "✓ Plugin built successfully: dist/pytest-language-server-0.5.1.zip"
-ls -lh pytest-language-server-0.5.1.zip
+echo "✓ Plugin built successfully: dist/pytest-language-server-${VERSION}.zip"
+ls -lh pytest-language-server-${VERSION}.zip

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/extensions/intellij-plugin/src/main/resources/META-INF/plugin.xml

@@ -1,7 +1,7 @@
 <idea-plugin>
     <id>com.github.bellini666.pytest-language-server</id>
     <name>pytest Language Server</name>
-    <version>0.5.2</version>
+    <version>0.6.0</version>
     <vendor email="hackedbellini@gmail.com" url="https://github.com/bellini666/pytest-language-server">Thiago Bellini Ribeiro</vendor>
 
     <description><![CDATA[

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/extensions/vscode-extension/.vscodeignore

@@ -12,3 +12,6 @@ node_modules/**
 out/**
 .eslintrc.json
 tsconfig.json
+
+# Include bundled binaries
+!bin/**

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/extensions/vscode-extension/package.json

@@ -2,7 +2,7 @@
   "name": "pytest-language-server",
   "displayName": "pytest Language Server",
   "description": "A blazingly fast Language Server Protocol implementation for pytest fixtures",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "publisher": "bellini666",
   "license": "MIT",
   "author": "Thiago Bellini Ribeiro <hackedbellini@gmail.com>",

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pytest-language-server"
-version = "0.5.2"
+version = "0.6.0"
 description = "A blazingly fast Language Server Protocol implementation for pytest"
 authors = [{name = "Thiago Bellini Ribeiro", email = "hackedbellini@gmail.com"}]
 readme = "README.md"

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/src/fixtures.rs

@@ -1935,6 +1935,174 @@ impl FixtureDatabase {
             .map(|entry| entry.value().clone())
             .unwrap_or_default()
     }
+
+    /// Get all available fixtures for a given file, respecting pytest's fixture hierarchy
+    /// Returns a list of fixture definitions sorted by name
+    pub fn get_available_fixtures(&self, file_path: &Path) -> Vec<FixtureDefinition> {
+        let mut available_fixtures = Vec::new();
+        let mut seen_names = std::collections::HashSet::new();
+
+        // Priority 1: Fixtures in the same file
+        for entry in self.definitions.iter() {
+            let fixture_name = entry.key();
+            for def in entry.value().iter() {
+                if def.file_path == file_path && !seen_names.contains(fixture_name.as_str()) {
+                    available_fixtures.push(def.clone());
+                    seen_names.insert(fixture_name.clone());
+                }
+            }
+        }
+
+        // Priority 2: Fixtures in conftest.py files (walking up the directory tree)
+        if let Some(mut current_dir) = file_path.parent() {
+            loop {
+                let conftest_path = current_dir.join("conftest.py");
+
+                for entry in self.definitions.iter() {
+                    let fixture_name = entry.key();
+                    for def in entry.value().iter() {
+                        if def.file_path == conftest_path
+                            && !seen_names.contains(fixture_name.as_str())
+                        {
+                            available_fixtures.push(def.clone());
+                            seen_names.insert(fixture_name.clone());
+                        }
+                    }
+                }
+
+                // Move up one directory
+                match current_dir.parent() {
+                    Some(parent) => current_dir = parent,
+                    None => break,
+                }
+            }
+        }
+
+        // Priority 3: Third-party fixtures from site-packages
+        for entry in self.definitions.iter() {
+            let fixture_name = entry.key();
+            for def in entry.value().iter() {
+                if def.file_path.to_string_lossy().contains("site-packages")
+                    && !seen_names.contains(fixture_name.as_str())
+                {
+                    available_fixtures.push(def.clone());
+                    seen_names.insert(fixture_name.clone());
+                }
+            }
+        }
+
+        // Sort by name for consistent ordering
+        available_fixtures.sort_by(|a, b| a.name.cmp(&b.name));
+        available_fixtures
+    }
+
+    /// Check if a position is inside a test or fixture function (parameter or body)
+    /// Returns Some((function_name, is_fixture, declared_params)) if inside a function
+    pub fn is_inside_function(
+        &self,
+        file_path: &Path,
+        line: u32,
+        character: u32,
+    ) -> Option<(String, bool, Vec<String>)> {
+        // Try cache first, then file system
+        let content: Arc<String> = if let Some(cached) = self.file_cache.get(file_path) {
+            Arc::clone(cached.value())
+        } else {
+            Arc::new(std::fs::read_to_string(file_path).ok()?)
+        };
+
+        let target_line = (line + 1) as usize; // Convert to 1-based
+
+        // Parse the file
+        let parsed = parse(&content, Mode::Module, "").ok()?;
+
+        if let rustpython_parser::ast::Mod::Module(module) = parsed {
+            return self.find_enclosing_function(
+                &module.body,
+                &content,
+                target_line,
+                character as usize,
+            );
+        }
+
+        None
+    }
+
+    fn find_enclosing_function(
+        &self,
+        stmts: &[Stmt],
+        content: &str,
+        target_line: usize,
+        _target_char: usize,
+    ) -> Option<(String, bool, Vec<String>)> {
+        for stmt in stmts {
+            match stmt {
+                Stmt::FunctionDef(func_def) => {
+                    let func_start_line = content[..func_def.range.start().to_usize()]
+                        .matches('\n')
+                        .count()
+                        + 1;
+                    let func_end_line = content[..func_def.range.end().to_usize()]
+                        .matches('\n')
+                        .count()
+                        + 1;
+
+                    // Check if target is within this function's range
+                    if target_line >= func_start_line && target_line <= func_end_line {
+                        let is_fixture = func_def
+                            .decorator_list
+                            .iter()
+                            .any(Self::is_fixture_decorator);
+                        let is_test = func_def.name.starts_with("test_");
+
+                        // Only return if it's a test or fixture
+                        if is_test || is_fixture {
+                            let params: Vec<String> = func_def
+                                .args
+                                .args
+                                .iter()
+                                .map(|arg| arg.def.arg.to_string())
+                                .collect();
+
+                            return Some((func_def.name.to_string(), is_fixture, params));
+                        }
+                    }
+                }
+                Stmt::AsyncFunctionDef(func_def) => {
+                    let func_start_line = content[..func_def.range.start().to_usize()]
+                        .matches('\n')
+                        .count()
+                        + 1;
+                    let func_end_line = content[..func_def.range.end().to_usize()]
+                        .matches('\n')
+                        .count()
+                        + 1;
+
+                    if target_line >= func_start_line && target_line <= func_end_line {
+                        let is_fixture = func_def
+                            .decorator_list
+                            .iter()
+                            .any(Self::is_fixture_decorator);
+                        let is_test = func_def.name.starts_with("test_");
+
+                        if is_test || is_fixture {
+                            let params: Vec<String> = func_def
+                                .args
+                                .args
+                                .iter()
+                                .map(|arg| arg.def.arg.to_string())
+                                .collect();
+
+                            return Some((func_def.name.to_string(), is_fixture, params));
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        None
+    }
 }
 
 #[cfg(test)]
@@ -4497,3 +4665,297 @@ def test_mid(fixture_a, fixture_c):
         "fixture_a from mid-level test should resolve to mid conftest"
     );
 }
+
+#[test]
+fn test_get_available_fixtures_same_file() {
+    let db = FixtureDatabase::new();
+
+    let test_content = r#"
+import pytest
+
+@pytest.fixture
+def fixture_a():
+    return "a"
+
+@pytest.fixture
+def fixture_b():
+    return "b"
+
+def test_something():
+    pass
+"#;
+    let test_path = PathBuf::from("/tmp/test/test_example.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    let available = db.get_available_fixtures(&test_path);
+
+    assert_eq!(available.len(), 2, "Should find 2 fixtures in same file");
+
+    let names: Vec<_> = available.iter().map(|f| f.name.as_str()).collect();
+    assert!(names.contains(&"fixture_a"));
+    assert!(names.contains(&"fixture_b"));
+}
+
+#[test]
+fn test_get_available_fixtures_conftest_hierarchy() {
+    let db = FixtureDatabase::new();
+
+    // Root conftest
+    let root_conftest = r#"
+import pytest
+
+@pytest.fixture
+def root_fixture():
+    return "root"
+"#;
+    let root_path = PathBuf::from("/tmp/test/conftest.py");
+    db.analyze_file(root_path.clone(), root_conftest);
+
+    // Subdir conftest
+    let sub_conftest = r#"
+import pytest
+
+@pytest.fixture
+def sub_fixture():
+    return "sub"
+"#;
+    let sub_path = PathBuf::from("/tmp/test/subdir/conftest.py");
+    db.analyze_file(sub_path.clone(), sub_conftest);
+
+    // Test file in subdir
+    let test_content = r#"
+def test_something():
+    pass
+"#;
+    let test_path = PathBuf::from("/tmp/test/subdir/test_example.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    let available = db.get_available_fixtures(&test_path);
+
+    assert_eq!(
+        available.len(),
+        2,
+        "Should find fixtures from both conftest files"
+    );
+
+    let names: Vec<_> = available.iter().map(|f| f.name.as_str()).collect();
+    assert!(names.contains(&"root_fixture"));
+    assert!(names.contains(&"sub_fixture"));
+}
+
+#[test]
+fn test_get_available_fixtures_no_duplicates() {
+    let db = FixtureDatabase::new();
+
+    // Root conftest
+    let root_conftest = r#"
+import pytest
+
+@pytest.fixture
+def shared_fixture():
+    return "root"
+"#;
+    let root_path = PathBuf::from("/tmp/test/conftest.py");
+    db.analyze_file(root_path.clone(), root_conftest);
+
+    // Subdir conftest with same fixture name
+    let sub_conftest = r#"
+import pytest
+
+@pytest.fixture
+def shared_fixture():
+    return "sub"
+"#;
+    let sub_path = PathBuf::from("/tmp/test/subdir/conftest.py");
+    db.analyze_file(sub_path.clone(), sub_conftest);
+
+    // Test file in subdir
+    let test_content = r#"
+def test_something():
+    pass
+"#;
+    let test_path = PathBuf::from("/tmp/test/subdir/test_example.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    let available = db.get_available_fixtures(&test_path);
+
+    // Should only find one "shared_fixture" (the closest one)
+    let shared_count = available
+        .iter()
+        .filter(|f| f.name == "shared_fixture")
+        .count();
+    assert_eq!(shared_count, 1, "Should only include shared_fixture once");
+
+    // The one included should be from the subdir (closest)
+    let shared_fixture = available
+        .iter()
+        .find(|f| f.name == "shared_fixture")
+        .unwrap();
+    assert_eq!(shared_fixture.file_path, sub_path);
+}
+
+#[test]
+fn test_is_inside_function_in_test() {
+    let db = FixtureDatabase::new();
+
+    let test_content = r#"
+import pytest
+
+def test_example(fixture_a, fixture_b):
+    result = fixture_a + fixture_b
+    assert result == "ab"
+"#;
+    let test_path = PathBuf::from("/tmp/test/test_example.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    // Test on the function definition line (line 4, 0-indexed line 3)
+    let result = db.is_inside_function(&test_path, 3, 10);
+    assert!(result.is_some());
+
+    let (func_name, is_fixture, params) = result.unwrap();
+    assert_eq!(func_name, "test_example");
+    assert!(!is_fixture);
+    assert_eq!(params, vec!["fixture_a", "fixture_b"]);
+
+    // Test inside the function body (line 5, 0-indexed line 4)
+    let result = db.is_inside_function(&test_path, 4, 10);
+    assert!(result.is_some());
+
+    let (func_name, is_fixture, _) = result.unwrap();
+    assert_eq!(func_name, "test_example");
+    assert!(!is_fixture);
+}
+
+#[test]
+fn test_is_inside_function_in_fixture() {
+    let db = FixtureDatabase::new();
+
+    let test_content = r#"
+import pytest
+
+@pytest.fixture
+def my_fixture(other_fixture):
+    return other_fixture + "_modified"
+"#;
+    let test_path = PathBuf::from("/tmp/test/conftest.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    // Test on the function definition line (line 5, 0-indexed line 4)
+    let result = db.is_inside_function(&test_path, 4, 10);
+    assert!(result.is_some());
+
+    let (func_name, is_fixture, params) = result.unwrap();
+    assert_eq!(func_name, "my_fixture");
+    assert!(is_fixture);
+    assert_eq!(params, vec!["other_fixture"]);
+
+    // Test inside the function body (line 6, 0-indexed line 5)
+    let result = db.is_inside_function(&test_path, 5, 10);
+    assert!(result.is_some());
+
+    let (func_name, is_fixture, _) = result.unwrap();
+    assert_eq!(func_name, "my_fixture");
+    assert!(is_fixture);
+}
+
+#[test]
+fn test_is_inside_function_outside() {
+    let db = FixtureDatabase::new();
+
+    let test_content = r#"
+import pytest
+
+@pytest.fixture
+def my_fixture():
+    return "value"
+
+def test_example(my_fixture):
+    assert my_fixture == "value"
+
+# This is a comment outside any function
+"#;
+    let test_path = PathBuf::from("/tmp/test/test_example.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    // Test on the import line (line 1, 0-indexed line 0)
+    let result = db.is_inside_function(&test_path, 0, 0);
+    assert!(
+        result.is_none(),
+        "Should not be inside a function on import line"
+    );
+
+    // Test on the comment line (line 10, 0-indexed line 9)
+    let result = db.is_inside_function(&test_path, 9, 0);
+    assert!(
+        result.is_none(),
+        "Should not be inside a function on comment line"
+    );
+}
+
+#[test]
+fn test_is_inside_function_non_test() {
+    let db = FixtureDatabase::new();
+
+    let test_content = r#"
+import pytest
+
+def helper_function():
+    return "helper"
+
+def test_example():
+    result = helper_function()
+    assert result == "helper"
+"#;
+    let test_path = PathBuf::from("/tmp/test/test_example.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    // Test inside helper_function (not a test or fixture)
+    let result = db.is_inside_function(&test_path, 3, 10);
+    assert!(
+        result.is_none(),
+        "Should not return non-test, non-fixture functions"
+    );
+
+    // Test inside test_example (is a test)
+    let result = db.is_inside_function(&test_path, 6, 10);
+    assert!(result.is_some(), "Should return test functions");
+
+    let (func_name, is_fixture, _) = result.unwrap();
+    assert_eq!(func_name, "test_example");
+    assert!(!is_fixture);
+}
+
+#[test]
+fn test_is_inside_async_function() {
+    let db = FixtureDatabase::new();
+
+    let test_content = r#"
+import pytest
+
+@pytest.fixture
+async def async_fixture():
+    return "async_value"
+
+async def test_async_example(async_fixture):
+    assert async_fixture == "async_value"
+"#;
+    let test_path = PathBuf::from("/tmp/test/test_async.py");
+    db.analyze_file(test_path.clone(), test_content);
+
+    // Test inside async fixture (line 5, 0-indexed line 4)
+    let result = db.is_inside_function(&test_path, 4, 10);
+    assert!(result.is_some());
+
+    let (func_name, is_fixture, _) = result.unwrap();
+    assert_eq!(func_name, "async_fixture");
+    assert!(is_fixture);
+
+    // Test inside async test (line 8, 0-indexed line 7)
+    let result = db.is_inside_function(&test_path, 7, 10);
+    assert!(result.is_some());
+
+    let (func_name, is_fixture, params) = result.unwrap();
+    assert_eq!(func_name, "test_async_example");
+    assert!(!is_fixture);
+    assert_eq!(params, vec!["async_fixture"]);
+}

{pytest_language_server-0.5.2 → pytest_language_server-0.6.0}/src/main.rs

@@ -58,6 +58,15 @@ impl LanguageServer for Backend {
                         resolve_provider: None,
                     },
                 )),
+                completion_provider: Some(CompletionOptions {
+                    resolve_provider: Some(false),
+                    trigger_characters: Some(vec![]),
+                    all_commit_characters: None,
+                    work_done_progress_options: WorkDoneProgressOptions {
+                        work_done_progress: None,
+                    },
+                    completion_item: None,
+                }),
                 ..Default::default()
             },
         })
@@ -441,6 +450,70 @@ impl LanguageServer for Backend {
         Ok(None)
     }
 
+    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        let uri = params.text_document_position.text_document.uri;
+        let position = params.text_document_position.position;
+
+        info!(
+            "completion request: uri={:?}, line={}, char={}",
+            uri, position.line, position.character
+        );
+
+        if let Ok(file_path) = uri.to_file_path() {
+            // Check if we're inside a test or fixture function
+            if let Some((function_name, is_fixture, declared_params)) = self
+                .fixture_db
+                .is_inside_function(&file_path, position.line, position.character)
+            {
+                info!(
+                    "Inside function '{}' (is_fixture={}, params={:?})",
+                    function_name, is_fixture, declared_params
+                );
+
+                // Get all available fixtures for this file
+                let available_fixtures = self.fixture_db.get_available_fixtures(&file_path);
+                info!("Found {} available fixtures", available_fixtures.len());
+
+                // Convert to completion items
+                let completion_items: Vec<CompletionItem> = available_fixtures
+                    .into_iter()
+                    .map(|fixture| {
+                        let mut detail = "pytest fixture".to_string();
+                        if let Some(file_name) = fixture.file_path.file_name() {
+                            detail.push_str(&format!(" from {}", file_name.to_string_lossy()));
+                        }
+
+                        let documentation = fixture.docstring.as_ref().map(|doc| {
+                            Documentation::MarkupContent(MarkupContent {
+                                kind: MarkupKind::Markdown,
+                                value: doc.clone(),
+                            })
+                        });
+
+                        CompletionItem {
+                            label: fixture.name.clone(),
+                            kind: Some(CompletionItemKind::VALUE),
+                            detail: Some(detail),
+                            documentation,
+                            insert_text: Some(fixture.name.clone()),
+                            insert_text_format: Some(InsertTextFormat::PLAIN_TEXT),
+                            ..Default::default()
+                        }
+                    })
+                    .collect();
+
+                info!("Returning {} completion items", completion_items.len());
+                return Ok(Some(CompletionResponse::Array(completion_items)));
+            } else {
+                info!("Not inside a test or fixture function");
+            }
+        } else {
+            warn!("Failed to convert URI to file path: {:?}", uri);
+        }
+
+        Ok(None)
+    }
+
     async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
         let uri = params.text_document.uri;
         let context = params.context;