fix: resolve CI test failure in output.py
- Fixed undefined 'tool' variable in display_history function - Changed '[tool]' markup tag usage to proper Rich syntax - All tests now pass (38/38 unit tests) - Type checking passes with mypy --strict
This commit is contained in:
Auto User
21
LICENSE
Normal file
21
LICENSE
Normal file
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2024 cli-diff-auditor Contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
231
README.md
Normal file
231
README.md
Normal file
@@ -0,0 +1,231 @@
|
||||
# Shell Speak
|
||||
|
||||
A CLI tool that converts natural language descriptions into shell commands. Uses local pattern matching without APIs. Supports docker, kubectl, git, and unix utilities. Includes interactive mode, command history, and learning from user corrections.
|
||||
|
||||
## Features
|
||||
|
||||
- **Natural Language Parsing**: Convert plain English to shell commands
|
||||
- **Multi-tool Support**: Docker, kubectl, Git, and Unix utilities
|
||||
- **Interactive Mode**: REPL-like interface with auto-completion and history
|
||||
- **Learning System**: Teach the tool new commands from your corrections
|
||||
- **Command History**: Persistent history of all conversions
|
||||
- **Rich Output**: Beautiful syntax-highlighted command display
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
pip install shell-speak
|
||||
```
|
||||
|
||||
Or from source:
|
||||
|
||||
```bash
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
## Quick Start
|
||||
|
||||
### Single Command Conversion
|
||||
|
||||
```bash
|
||||
# Convert a natural language query to a command
|
||||
shell-speak "list running docker containers"
|
||||
|
||||
# Filter by specific tool
|
||||
shell-speak --tool docker "show all containers"
|
||||
|
||||
# Get detailed explanation
|
||||
shell-speak --explain "commit changes with message 'fix bug'"
|
||||
```
|
||||
|
||||
### Interactive Mode
|
||||
|
||||
Enter interactive mode for a REPL-like experience:
|
||||
|
||||
```bash
|
||||
shell-speak interactive
|
||||
# or just
|
||||
shell-speak
|
||||
```
|
||||
|
||||
In interactive mode:
|
||||
- Type natural language queries
|
||||
- Use up/down arrows to navigate command history
|
||||
- Tab for auto-completion
|
||||
- `help` for available commands
|
||||
- `exit` to quit
|
||||
|
||||
## Usage
|
||||
|
||||
### Command Reference
|
||||
|
||||
| Command | Description |
|
||||
|---------|-------------|
|
||||
| `shell-speak "query"` | Convert query to command |
|
||||
| `shell-speak interactive` | Enter interactive mode |
|
||||
| `shell-speak history` | View command history |
|
||||
| `shell-speak learn "query" "command"` | Teach a new pattern |
|
||||
| `shell-speak forget "query"` | Remove a learned pattern |
|
||||
| `shell-speak tools` | List supported tools |
|
||||
| `shell-speak reload` | Reload command libraries |
|
||||
|
||||
### Options
|
||||
|
||||
| Option | Description |
|
||||
|--------|-------------|
|
||||
| `--tool, -t` | Filter by tool (docker/kubectl/git/unix) |
|
||||
| `--explain, -e` | Show detailed explanation |
|
||||
| `--dry-run, -n` | Preview without executing |
|
||||
| `--version, -V` | Show version |
|
||||
| `--help` | Show help |
|
||||
|
||||
### Examples
|
||||
|
||||
```bash
|
||||
# Docker commands
|
||||
shell-speak "list running containers"
|
||||
shell-speak "stop container nginx"
|
||||
shell-speak "build image with tag myapp:latest"
|
||||
|
||||
# Kubernetes commands
|
||||
shell-speak "get pods in default namespace"
|
||||
shell-speak "describe deployment myapp"
|
||||
shell-speak "scale deployment to 3 replicas"
|
||||
|
||||
# Git commands
|
||||
shell-speak "commit changes with message 'fix bug'"
|
||||
shell-speak "push to origin main"
|
||||
shell-speak "create new branch feature/auth"
|
||||
|
||||
# Unix commands
|
||||
shell-speak "list files with details"
|
||||
shell-speak "find files named *.py"
|
||||
shell-speak "search for pattern in files"
|
||||
```
|
||||
|
||||
## Interactive Mode
|
||||
|
||||
Interactive mode provides a rich shell-like experience:
|
||||
|
||||
```
|
||||
$ shell-speak
|
||||
[shell-speak]>> list running containers
|
||||
[docker] command
|
||||
+------------------+
|
||||
| docker ps |
|
||||
+------------------+
|
||||
|
||||
[shell-speak]>> help
|
||||
[shell-speak]>> help
|
||||
```
|
||||
|
||||
### Interactive Commands
|
||||
|
||||
| Command | Description |
|
||||
|---------|-------------|
|
||||
| `help` | Show help message |
|
||||
| `clear` | Clear screen |
|
||||
| `history` | Show command history |
|
||||
| `repeat <n>` | Repeat nth command from history |
|
||||
| `learn <query>::<command>::<tool>` | Learn new pattern |
|
||||
| `forget <query>` | Forget a pattern |
|
||||
| `exit` | Exit interactive mode |
|
||||
|
||||
## Learning from Corrections
|
||||
|
||||
Shell Speak can learn from your corrections. When the suggested command isn't quite right, teach it the correct version:
|
||||
|
||||
```bash
|
||||
# In interactive mode
|
||||
shell-speak>> learn "deploy to prod" "kubectl apply -f prod/" "kubectl"
|
||||
```
|
||||
|
||||
Or via CLI:
|
||||
|
||||
```bash
|
||||
shell-speak learn "deploy to prod" "kubectl apply -f prod/" --tool kubectl
|
||||
```
|
||||
|
||||
## Command Library
|
||||
|
||||
Shell Speak includes extensive command libraries for:
|
||||
|
||||
### Docker
|
||||
- Container management (ps, run, stop, rm)
|
||||
- Image operations (pull, build, push)
|
||||
- Docker Compose commands
|
||||
- Volume and network management
|
||||
|
||||
### Kubernetes
|
||||
- Pod operations (get, describe, logs, exec)
|
||||
- Deployment management
|
||||
- Service and ingress operations
|
||||
- ConfigMaps and Secrets
|
||||
- Cluster information
|
||||
|
||||
### Git
|
||||
- Commit and push operations
|
||||
- Branch management
|
||||
- Merge and rebase
|
||||
- Stash and tag operations
|
||||
- Remote management
|
||||
|
||||
### Unix
|
||||
- File and directory operations
|
||||
- Search and find commands
|
||||
- Process management
|
||||
- Network utilities
|
||||
- Archive operations
|
||||
|
||||
## Configuration
|
||||
|
||||
### Environment Variables
|
||||
|
||||
| Variable | Description | Default |
|
||||
|----------|-------------|---------|
|
||||
| `SHELL_SPEAK_DATA_DIR` | Data directory for libraries | `~/.local/share/shell-speak` |
|
||||
| `SHELL_SPEAK_HISTORY_FILE` | History file path | `~/.local/share/shell-speak/history.json` |
|
||||
| `SHELL_SPEAK_CORRECTIONS_FILE` | Corrections file path | `~/.local/share/shell-speak/corrections.json` |
|
||||
|
||||
## Testing
|
||||
|
||||
```bash
|
||||
# Run all tests
|
||||
pytest tests/ -v
|
||||
|
||||
# Run with coverage
|
||||
pytest tests/ --cov=shell_speak --cov-report=term-missing
|
||||
|
||||
# Run specific test file
|
||||
pytest tests/test_pattern_matching.py -v
|
||||
```
|
||||
|
||||
## Extending the Command Library
|
||||
|
||||
Add custom command patterns by creating YAML files in the data directory:
|
||||
|
||||
```yaml
|
||||
version: "1.0"
|
||||
description: Custom commands
|
||||
|
||||
patterns:
|
||||
- name: my_custom_command
|
||||
description: A custom command
|
||||
patterns:
|
||||
- do something custom
|
||||
- run my command
|
||||
template: my_command --option {value}
|
||||
explanation: What this command does
|
||||
```
|
||||
|
||||
## Contributing
|
||||
|
||||
1. Fork the repository
|
||||
2. Create a feature branch
|
||||
3. Add your command patterns
|
||||
4. Write tests
|
||||
5. Submit a pull request
|
||||
|
||||
## License
|
||||
|
||||
MIT License - see [LICENSE](LICENSE) file for details.
|
||||
238
commands/docker.yaml
Normal file
238
commands/docker.yaml
Normal file
@@ -0,0 +1,238 @@
|
||||
version: "1.0"
|
||||
description: Docker command patterns
|
||||
|
||||
patterns:
|
||||
- name: list_containers
|
||||
description: List running containers
|
||||
patterns:
|
||||
- list running containers
|
||||
- show running containers
|
||||
- list containers
|
||||
- show all containers
|
||||
- docker ps
|
||||
template: docker ps
|
||||
explanation: Lists all running containers with their IDs, images, and status.
|
||||
|
||||
- name: list_all_containers
|
||||
description: List all containers including stopped ones
|
||||
patterns:
|
||||
- list all containers including stopped
|
||||
- show all containers
|
||||
- list all docker containers
|
||||
template: docker ps -a
|
||||
explanation: Lists all containers, including stopped ones.
|
||||
|
||||
- name: list_images
|
||||
description: List Docker images
|
||||
patterns:
|
||||
- list docker images
|
||||
- show images
|
||||
- list images
|
||||
- docker images
|
||||
template: docker images
|
||||
explanation: Lists all Docker images stored locally.
|
||||
|
||||
- name: run_container
|
||||
description: Run a new container
|
||||
patterns:
|
||||
- run a container
|
||||
- start a new container
|
||||
- run docker container
|
||||
- docker run
|
||||
template: docker run -d --name {name} {image}
|
||||
explanation: Starts a new detached container with the specified image.
|
||||
|
||||
- name: run_container_interactive
|
||||
description: Run a container in interactive mode
|
||||
patterns:
|
||||
- run container interactively
|
||||
- run container with terminal
|
||||
- docker run -it
|
||||
template: docker run -it --rm {image}
|
||||
explanation: Runs a container interactively with a terminal.
|
||||
|
||||
- name: stop_container
|
||||
description: Stop a running container
|
||||
patterns:
|
||||
- stop container
|
||||
- stop docker container
|
||||
- stop running container
|
||||
template: docker stop {container}
|
||||
explanation: Stops the specified running container.
|
||||
|
||||
- name: start_container
|
||||
description: Start a stopped container
|
||||
patterns:
|
||||
- start container
|
||||
- start docker container
|
||||
template: docker start {container}
|
||||
explanation: Starts a previously stopped container.
|
||||
|
||||
- name: remove_container
|
||||
description: Remove a container
|
||||
patterns:
|
||||
- remove container
|
||||
- delete container
|
||||
- docker rm
|
||||
template: docker rm {container}
|
||||
explanation: Removes the specified container.
|
||||
|
||||
- name: remove_container_force
|
||||
description: Force remove a running container
|
||||
patterns:
|
||||
- force remove container
|
||||
- delete container forcefully
|
||||
- remove container force
|
||||
template: docker rm -f {container}
|
||||
explanation: Forcefully removes a running container.
|
||||
|
||||
- name: remove_image
|
||||
description: Remove a Docker image
|
||||
patterns:
|
||||
- remove image
|
||||
- delete image
|
||||
- docker rmi
|
||||
template: docker rmi {image}
|
||||
explanation: Removes the specified Docker image.
|
||||
|
||||
- name: pull_image
|
||||
description: Pull a Docker image
|
||||
patterns:
|
||||
- pull image
|
||||
- download image
|
||||
- docker pull
|
||||
template: docker pull {image}
|
||||
explanation: Pulls a Docker image from the registry.
|
||||
|
||||
- name: build_image
|
||||
description: Build a Docker image from Dockerfile
|
||||
patterns:
|
||||
- build image
|
||||
- build docker image
|
||||
- docker build
|
||||
template: docker build -t {tag} .
|
||||
explanation: Builds a Docker image tagged with the specified name.
|
||||
|
||||
- name: push_image
|
||||
description: Push an image to registry
|
||||
patterns:
|
||||
- push image
|
||||
- push to registry
|
||||
- docker push
|
||||
template: docker push {image}
|
||||
explanation: Pushes a Docker image to the registry.
|
||||
|
||||
- name: container_logs
|
||||
description: View container logs
|
||||
patterns:
|
||||
- view logs
|
||||
- container logs
|
||||
- docker logs
|
||||
template: docker logs -f {container}
|
||||
explanation: Shows logs from the specified container.
|
||||
|
||||
- name: exec_container
|
||||
description: Execute command in container
|
||||
patterns:
|
||||
- exec into container
|
||||
- run command in container
|
||||
- docker exec
|
||||
template: docker exec -it {container} {command}
|
||||
explanation: Executes a command inside a running container.
|
||||
|
||||
- name: inspect_container
|
||||
description: Inspect container details
|
||||
patterns:
|
||||
- inspect container
|
||||
- container details
|
||||
- docker inspect
|
||||
template: docker inspect {container}
|
||||
explanation: Shows detailed information about a container.
|
||||
|
||||
- name: container_stats
|
||||
description: Show container resource usage
|
||||
patterns:
|
||||
- container stats
|
||||
- resource usage
|
||||
- docker stats
|
||||
template: docker stats
|
||||
explanation: Shows live resource usage statistics for containers.
|
||||
|
||||
- name: prune_containers
|
||||
description: Remove stopped containers
|
||||
patterns:
|
||||
- prune containers
|
||||
- cleanup containers
|
||||
- remove stopped containers
|
||||
template: docker container prune -f
|
||||
explanation: Removes all stopped containers.
|
||||
|
||||
- name: prune_images
|
||||
description: Remove unused images
|
||||
patterns:
|
||||
- prune images
|
||||
- cleanup images
|
||||
- remove unused images
|
||||
template: docker image prune -f
|
||||
explanation: Removes unused (dangling) images.
|
||||
|
||||
- name: prune_all
|
||||
description: Remove all unused resources
|
||||
patterns:
|
||||
- prune all
|
||||
- cleanup everything
|
||||
- docker system prune
|
||||
template: docker system prune -af
|
||||
explanation: Removes all stopped containers, unused networks, and dangling images.
|
||||
|
||||
- name: docker_compose_up
|
||||
description: Start services with docker-compose
|
||||
patterns:
|
||||
- docker compose up
|
||||
- start services
|
||||
- docker-compose up
|
||||
template: docker-compose up -d
|
||||
explanation: Starts all services defined in docker-compose.yml.
|
||||
|
||||
- name: docker_compose_down
|
||||
description: Stop services with docker-compose
|
||||
patterns:
|
||||
- docker compose down
|
||||
- stop services
|
||||
- docker-compose down
|
||||
template: docker-compose down
|
||||
explanation: Stops and removes all services defined in docker-compose.yml.
|
||||
|
||||
- name: docker_compose_logs
|
||||
description: View docker-compose logs
|
||||
patterns:
|
||||
- compose logs
|
||||
- docker compose logs
|
||||
- docker-compose logs
|
||||
template: docker-compose logs -f
|
||||
explanation: Shows logs from all compose services.
|
||||
|
||||
- name: docker_compose_build
|
||||
description: Build docker-compose services
|
||||
patterns:
|
||||
- compose build
|
||||
- docker compose build
|
||||
- docker-compose build
|
||||
template: docker-compose build
|
||||
explanation: Builds all services defined in docker-compose.yml.
|
||||
|
||||
- name: network_list
|
||||
description: List Docker networks
|
||||
patterns:
|
||||
- list networks
|
||||
- docker network ls
|
||||
template: docker network ls
|
||||
explanation: Lists all Docker networks.
|
||||
|
||||
- name: volume_list
|
||||
description: List Docker volumes
|
||||
patterns:
|
||||
- list volumes
|
||||
- docker volume ls
|
||||
template: docker volume ls
|
||||
explanation: Lists all Docker volumes.
|
||||
559
commands/git.yaml
Normal file
559
commands/git.yaml
Normal file
@@ -0,0 +1,559 @@
|
||||
version: "1.0"
|
||||
description: Git command patterns
|
||||
|
||||
patterns:
|
||||
- name: git_init
|
||||
description: Initialize a new git repository
|
||||
patterns:
|
||||
- initialize git
|
||||
- start git repo
|
||||
- git init
|
||||
template: git init
|
||||
explanation: Initializes a new Git repository in the current directory.
|
||||
|
||||
- name: git_clone
|
||||
description: Clone a repository
|
||||
patterns:
|
||||
- clone repository
|
||||
- clone repo
|
||||
- git clone
|
||||
template: git clone {url}
|
||||
explanation: Clones a remote repository to the local machine.
|
||||
|
||||
- name: git_clone_branch
|
||||
description: Clone a specific branch
|
||||
patterns:
|
||||
- clone branch
|
||||
- git clone branch
|
||||
template: git clone -b {branch} {url}
|
||||
explanation: Clones a specific branch from a repository.
|
||||
|
||||
- name: git_status
|
||||
description: Show working tree status
|
||||
patterns:
|
||||
- git status
|
||||
- check status
|
||||
- show changes
|
||||
template: git status
|
||||
explanation: Shows the current status of the working directory.
|
||||
|
||||
- name: git_add
|
||||
description: Add file contents to index
|
||||
patterns:
|
||||
- add file
|
||||
- stage file
|
||||
- git add
|
||||
template: git add {file}
|
||||
explanation: Adds file contents to the staging area.
|
||||
|
||||
- name: git_add_all
|
||||
description: Add all changes to index
|
||||
patterns:
|
||||
- add all
|
||||
- stage all
|
||||
- git add .
|
||||
template: git add .
|
||||
explanation: Adds all changes to the staging area.
|
||||
|
||||
- name: git_add_pattern
|
||||
description: Add files matching pattern
|
||||
patterns:
|
||||
- add pattern
|
||||
- git add glob
|
||||
template: git add '{pattern}'
|
||||
explanation: Adds all files matching the glob pattern.
|
||||
|
||||
- name: git_commit
|
||||
description: Commit changes
|
||||
patterns:
|
||||
- commit changes
|
||||
- make commit
|
||||
- git commit
|
||||
template: git commit -m "{message}"
|
||||
explanation: Records changes in the repository with a message.
|
||||
|
||||
- name: git_commit_amend
|
||||
description: Amend last commit
|
||||
patterns:
|
||||
- amend commit
|
||||
- modify last commit
|
||||
- git commit --amend
|
||||
template: git commit --amend -m "{message}"
|
||||
explanation: Modifies the last commit with new changes or message.
|
||||
|
||||
- name: git_commit_amend_no_msg
|
||||
description: Amend last commit without changing message
|
||||
patterns:
|
||||
- amend without message
|
||||
- git commit amend
|
||||
template: git commit --amend --no-edit
|
||||
explanation: Adds changes to the last commit without changing the message.
|
||||
|
||||
- name: git_push
|
||||
description: Push changes to remote
|
||||
patterns:
|
||||
- push changes
|
||||
- git push
|
||||
template: git push origin {branch}
|
||||
explanation: Pushes commits to the remote repository.
|
||||
|
||||
- name: git_push_tags
|
||||
description: Push tags to remote
|
||||
patterns:
|
||||
- push tags
|
||||
- git push tags
|
||||
template: git push origin --tags
|
||||
explanation: Pushes all tags to the remote repository.
|
||||
|
||||
- name: git_push_force
|
||||
description: Force push changes
|
||||
patterns:
|
||||
- force push
|
||||
- overwrite remote
|
||||
- git push --force
|
||||
template: git push --force origin {branch}
|
||||
explanation: Force pushes changes, overwriting remote history.
|
||||
|
||||
- name: git_pull
|
||||
description: Fetch and integrate changes
|
||||
patterns:
|
||||
- pull changes
|
||||
- git pull
|
||||
template: git pull origin {branch}
|
||||
explanation: Fetches and merges changes from remote.
|
||||
|
||||
- name: git_pull_rebase
|
||||
description: Pull with rebase
|
||||
patterns:
|
||||
- pull with rebase
|
||||
- git pull rebase
|
||||
template: git pull --rebase origin {branch}
|
||||
explanation: Fetches and rebases changes on top of local commits.
|
||||
|
||||
- name: git_fetch
|
||||
description: Fetch remote changes
|
||||
patterns:
|
||||
- fetch changes
|
||||
- git fetch
|
||||
template: git fetch origin
|
||||
explanation: Fetches changes from remote without merging.
|
||||
|
||||
- name: git_fetch_all
|
||||
description: Fetch from all remotes
|
||||
patterns:
|
||||
- fetch all
|
||||
- git fetch --all
|
||||
template: git fetch --all
|
||||
explanation: Fetches changes from all remotes.
|
||||
|
||||
- name: git_branch
|
||||
description: List branches
|
||||
patterns:
|
||||
- list branches
|
||||
- show branches
|
||||
- git branch
|
||||
template: git branch
|
||||
explanation: Lists all local branches.
|
||||
|
||||
- name: git_branch_remote
|
||||
description: List remote branches
|
||||
patterns:
|
||||
- remote branches
|
||||
- git branch -r
|
||||
template: git branch -r
|
||||
explanation: Lists all remote branches.
|
||||
|
||||
- name: git_branch_all
|
||||
description: List all branches
|
||||
patterns:
|
||||
- all branches
|
||||
- git branch -a
|
||||
template: git branch -a
|
||||
explanation: Lists all local and remote branches.
|
||||
|
||||
- name: git_checkout
|
||||
description: Switch to a branch
|
||||
patterns:
|
||||
- switch branch
|
||||
- checkout branch
|
||||
- git checkout
|
||||
template: git checkout {branch}
|
||||
explanation: Switches to the specified branch.
|
||||
|
||||
- name: git_checkout_new
|
||||
description: Create and switch to new branch
|
||||
patterns:
|
||||
- create branch
|
||||
- new branch
|
||||
- git checkout -b
|
||||
template: git checkout -b {branch}
|
||||
explanation: Creates a new branch and switches to it.
|
||||
|
||||
- name: git_checkout_file
|
||||
description: Discard changes to a file
|
||||
patterns:
|
||||
- discard file changes
|
||||
- checkout file
|
||||
- git checkout -- file
|
||||
template: git checkout -- {file}
|
||||
explanation: Discards local changes to a file.
|
||||
|
||||
- name: git_merge
|
||||
description: Merge a branch
|
||||
patterns:
|
||||
- merge branch
|
||||
- git merge
|
||||
template: git merge {branch}
|
||||
explanation: Merges the specified branch into current branch.
|
||||
|
||||
- name: git_merge_no_ff
|
||||
description: Merge with no fast-forward
|
||||
patterns:
|
||||
- merge no fast forward
|
||||
- git merge --no-ff
|
||||
template: git merge --no-ff {branch}
|
||||
explanation: Creates a merge commit even if fast-forward is possible.
|
||||
|
||||
- name: git_merge_abort
|
||||
description: Abort merge
|
||||
patterns:
|
||||
- abort merge
|
||||
- git merge --abort
|
||||
template: git merge --abort
|
||||
explanation: Aborts the current merge.
|
||||
|
||||
- name: git_rebase
|
||||
description: Rebase onto a branch
|
||||
patterns:
|
||||
- rebase
|
||||
- git rebase
|
||||
template: git rebase {branch}
|
||||
explanation: Rebases current branch onto the specified branch.
|
||||
|
||||
- name: git_rebase_interactive
|
||||
description: Interactive rebase
|
||||
patterns:
|
||||
- interactive rebase
|
||||
- git rebase -i
|
||||
template: git rebase -i {commit}
|
||||
explanation: Starts an interactive rebase to edit commits.
|
||||
|
||||
- name: git_rebase_continue
|
||||
description: Continue rebase
|
||||
patterns:
|
||||
- continue rebase
|
||||
- git rebase --continue
|
||||
template: git rebase --continue
|
||||
explanation: Continues rebase after resolving conflicts.
|
||||
|
||||
- name: git_rebase_abort
|
||||
description: Abort rebase
|
||||
patterns:
|
||||
- abort rebase
|
||||
- git rebase --abort
|
||||
template: git rebase --abort
|
||||
explanation: Aborts the current rebase.
|
||||
|
||||
- name: git_log
|
||||
description: Show commit history
|
||||
patterns:
|
||||
- show history
|
||||
- git log
|
||||
template: git log --oneline
|
||||
explanation: Shows commit history in a compact format.
|
||||
|
||||
- name: git_log_detailed
|
||||
description: Show detailed commit history
|
||||
patterns:
|
||||
- detailed log
|
||||
- git log full
|
||||
template: git log
|
||||
explanation: Shows detailed commit history.
|
||||
|
||||
- name: git_log_graph
|
||||
description: Show commit history with graph
|
||||
patterns:
|
||||
- graph log
|
||||
- git log graph
|
||||
template: git log --oneline --graph --all
|
||||
explanation: Shows commit history with a text-based graph.
|
||||
|
||||
- name: git_log_stat
|
||||
description: Show commit history with stats
|
||||
patterns:
|
||||
- log with stats
|
||||
- git log --stat
|
||||
template: git log --stat
|
||||
explanation: Shows commit history with file change statistics.
|
||||
|
||||
- name: git_diff
|
||||
description: Show changes between commits
|
||||
patterns:
|
||||
- show diff
|
||||
- git diff
|
||||
template: git diff
|
||||
explanation: Shows uncommitted changes.
|
||||
|
||||
- name: git_diff_staged
|
||||
description: Show staged changes
|
||||
patterns:
|
||||
- staged diff
|
||||
- git diff --cached
|
||||
template: git diff --cached
|
||||
explanation: Shows staged changes in the index.
|
||||
|
||||
- name: git_diff_branch
|
||||
description: Compare branches
|
||||
patterns:
|
||||
- diff branches
|
||||
- compare branches
|
||||
template: git diff {branch1} {branch2}
|
||||
explanation: Shows differences between two branches.
|
||||
|
||||
- name: git_show
|
||||
description: Show a commit
|
||||
patterns:
|
||||
- show commit
|
||||
- git show
|
||||
template: git show {commit}
|
||||
explanation: Shows details of a specific commit.
|
||||
|
||||
- name: git_stash
|
||||
description: Stash changes
|
||||
patterns:
|
||||
- stash changes
|
||||
- git stash
|
||||
template: git stash
|
||||
explanation: Temporarily shelves changes.
|
||||
|
||||
- name: git_stash_save
|
||||
description: Stash changes with message
|
||||
patterns:
|
||||
- stash with message
|
||||
- git stash save
|
||||
template: git stash save "{message}"
|
||||
explanation: Stashes changes with a descriptive message.
|
||||
|
||||
- name: git_stash_list
|
||||
description: List stashed changes
|
||||
patterns:
|
||||
- stash list
|
||||
- git stash list
|
||||
template: git stash list
|
||||
explanation: Lists all stashed changes.
|
||||
|
||||
- name: git_stash_pop
|
||||
description: Apply and remove stashed changes
|
||||
patterns:
|
||||
- stash pop
|
||||
- git stash pop
|
||||
template: git stash pop
|
||||
explanation: Applies stashed changes and removes from stash.
|
||||
|
||||
- name: git_stash_apply
|
||||
description: Apply stashed changes
|
||||
patterns:
|
||||
- stash apply
|
||||
- git stash apply
|
||||
template: git stash apply
|
||||
explanation: Applies stashed changes without removing them.
|
||||
|
||||
- name: git_stash_drop
|
||||
description: Drop a stash
|
||||
patterns:
|
||||
- drop stash
|
||||
- git stash drop
|
||||
template: git stash drop
|
||||
explanation: Removes a stashed change.
|
||||
|
||||
- name: git_tag
|
||||
description: Create a tag
|
||||
patterns:
|
||||
- create tag
|
||||
- git tag
|
||||
template: git tag {tag_name}
|
||||
explanation: Creates a tag at the current commit.
|
||||
|
||||
- name: git_tag_annotated
|
||||
description: Create an annotated tag
|
||||
patterns:
|
||||
- annotated tag
|
||||
- git tag -a
|
||||
template: git tag -a {tag_name} -m "{message}"
|
||||
explanation: Creates an annotated tag with a message.
|
||||
|
||||
- name: git_tag_delete
|
||||
description: Delete a tag
|
||||
patterns:
|
||||
- delete tag
|
||||
- git tag -d
|
||||
template: git tag -d {tag_name}
|
||||
explanation: Deletes a local tag.
|
||||
|
||||
- name: git_remote_add
|
||||
description: Add a remote
|
||||
patterns:
|
||||
- add remote
|
||||
- git remote add
|
||||
template: git remote add origin {url}
|
||||
explanation: Adds a new remote repository.
|
||||
|
||||
- name: git_remote_remove
|
||||
description: Remove a remote
|
||||
patterns:
|
||||
- remove remote
|
||||
- git remote remove
|
||||
template: git remote remove origin
|
||||
explanation: Removes a remote repository.
|
||||
|
||||
- name: git_remote_set_url
|
||||
description: Change remote URL
|
||||
patterns:
|
||||
- set remote url
|
||||
- git remote set-url
|
||||
template: git remote set-url origin {url}
|
||||
explanation: Changes the URL of a remote.
|
||||
|
||||
- name: git_remote_show
|
||||
description: Show remote details
|
||||
patterns:
|
||||
- show remote
|
||||
- git remote -v
|
||||
template: git remote -v
|
||||
explanation: Shows remote URLs with names.
|
||||
|
||||
- name: git_clean
|
||||
description: Remove untracked files
|
||||
patterns:
|
||||
- clean untracked
|
||||
- git clean
|
||||
template: git clean -fd
|
||||
explanation: Removes untracked files and directories.
|
||||
|
||||
- name: git_reset
|
||||
description: Reset current HEAD
|
||||
patterns:
|
||||
- reset head
|
||||
- git reset
|
||||
template: git reset HEAD
|
||||
explanation: Unstages changes but keeps them.
|
||||
|
||||
- name: git_reset_hard
|
||||
description: Hard reset to commit
|
||||
patterns:
|
||||
- hard reset
|
||||
- git reset --hard
|
||||
template: git reset --hard {commit}
|
||||
explanation: Resets to a commit, discarding all changes.
|
||||
|
||||
- name: git_reset_soft
|
||||
description: Soft reset to commit
|
||||
patterns:
|
||||
- soft reset
|
||||
- git reset --soft
|
||||
template: git reset --soft {commit}
|
||||
explanation: Resets to a commit but keeps changes staged.
|
||||
|
||||
- name: git_config_global
|
||||
description: Set global git config
|
||||
patterns:
|
||||
- set git config
|
||||
- git config global
|
||||
template: git config --global {key} "{value}"
|
||||
explanation: Sets a global Git configuration value.
|
||||
|
||||
- name: git_config_local
|
||||
description: Set local git config
|
||||
patterns:
|
||||
- set local config
|
||||
- git config local
|
||||
template: git config --local {key} "{value}"
|
||||
explanation: Sets a local Git configuration value.
|
||||
|
||||
- name: git_config_show
|
||||
description: Show git config
|
||||
patterns:
|
||||
- show git config
|
||||
- git config list
|
||||
template: git config --list
|
||||
explanation: Lists all Git configuration settings.
|
||||
|
||||
- name: git_grep
|
||||
description: Search for a pattern
|
||||
patterns:
|
||||
- search code
|
||||
- git grep
|
||||
template: git grep "{pattern}"
|
||||
explanation: Searches for a pattern in tracked files.
|
||||
|
||||
- name: git_blame
|
||||
description: Show blame for a file
|
||||
patterns:
|
||||
- blame file
|
||||
- git blame
|
||||
template: git blame {file}
|
||||
explanation: Shows who modified each line of a file.
|
||||
|
||||
- name: git_cherry_pick
|
||||
description: Apply a commit
|
||||
patterns:
|
||||
- cherry pick
|
||||
- git cherry-pick
|
||||
template: git cherry-pick {commit}
|
||||
explanation: Applies the changes from a specific commit.
|
||||
|
||||
- name: git_bisect_start
|
||||
description: Start bisect session
|
||||
patterns:
|
||||
- start bisect
|
||||
- git bisect
|
||||
template: git bisect start
|
||||
explanation: Starts a binary search for bugs.
|
||||
|
||||
- name: git_bisect_good
|
||||
description: Mark commit as good
|
||||
patterns:
|
||||
- mark good
|
||||
- git bisect good
|
||||
template: git bisect good
|
||||
explanation: Marks the current commit as good for bisect.
|
||||
|
||||
- name: git_bisect_bad
|
||||
description: Mark commit as bad
|
||||
patterns:
|
||||
- mark bad
|
||||
- git bisect bad
|
||||
template: git bisect bad
|
||||
explanation: Marks the current commit as bad for bisect.
|
||||
|
||||
- name: git_bisect_reset
|
||||
description: Reset bisect
|
||||
patterns:
|
||||
- reset bisect
|
||||
- git bisect reset
|
||||
template: git bisect reset
|
||||
explanation: Resets the bisect session.
|
||||
|
||||
- name: git_submodule_add
|
||||
description: Add a submodule
|
||||
patterns:
|
||||
- add submodule
|
||||
- git submodule add
|
||||
template: git submodule add {url} {path}
|
||||
explanation: Adds a Git repository as a submodule.
|
||||
|
||||
- name: git_submodule_update
|
||||
description: Update submodules
|
||||
patterns:
|
||||
- update submodules
|
||||
- git submodule update
|
||||
template: git submodule update --init --recursive
|
||||
explanation: Initializes and updates all submodules.
|
||||
|
||||
- name: git_submodule_status
|
||||
description: Check submodule status
|
||||
patterns:
|
||||
- submodule status
|
||||
- git submodule status
|
||||
template: git submodule status
|
||||
explanation: Shows the status of submodules.
|
||||
354
commands/kubectl.yaml
Normal file
354
commands/kubectl.yaml
Normal file
@@ -0,0 +1,354 @@
|
||||
version: "1.0"
|
||||
description: kubectl command patterns
|
||||
|
||||
patterns:
|
||||
- name: get_pods
|
||||
description: List pods in a namespace
|
||||
patterns:
|
||||
- list pods
|
||||
- get pods
|
||||
- show pods
|
||||
- kubectl get pods
|
||||
template: kubectl get pods -n {namespace}
|
||||
explanation: Lists all pods in the specified namespace.
|
||||
|
||||
- name: get_all_pods
|
||||
description: List all pods in all namespaces
|
||||
patterns:
|
||||
- list all pods
|
||||
- get all pods
|
||||
- kubectl get pods -A
|
||||
template: kubectl get pods -A
|
||||
explanation: Lists all pods across all namespaces.
|
||||
|
||||
- name: get_pod_details
|
||||
description: Get detailed pod information
|
||||
patterns:
|
||||
- pod details
|
||||
- describe pod
|
||||
- kubectl describe pod
|
||||
template: kubectl describe pod {pod_name} -n {namespace}
|
||||
explanation: Shows detailed information about a specific pod.
|
||||
|
||||
- name: get_pod_yaml
|
||||
description: Get pod YAML configuration
|
||||
patterns:
|
||||
- pod yaml
|
||||
- get pod yaml
|
||||
- kubectl get pod -o yaml
|
||||
template: kubectl get pod {pod_name} -n {namespace} -o yaml
|
||||
explanation: Returns the YAML configuration for a pod.
|
||||
|
||||
- name: delete_pod
|
||||
description: Delete a pod
|
||||
patterns:
|
||||
- delete pod
|
||||
- remove pod
|
||||
- kubectl delete pod
|
||||
template: kubectl delete pod {pod_name} -n {namespace}
|
||||
explanation: Deletes the specified pod.
|
||||
|
||||
- name: delete_pod_force
|
||||
description: Force delete a pod
|
||||
patterns:
|
||||
- force delete pod
|
||||
- delete pod immediately
|
||||
template: kubectl delete pod {pod_name} -n {namespace} --grace-period=0 --force
|
||||
explanation: Forcefully deletes a pod without waiting for graceful termination.
|
||||
|
||||
- name: get_deployments
|
||||
description: List deployments
|
||||
patterns:
|
||||
- list deployments
|
||||
- get deployments
|
||||
- kubectl get deployments
|
||||
template: kubectl get deployments -n {namespace}
|
||||
explanation: Lists all deployments in the namespace.
|
||||
|
||||
- name: get_deployment
|
||||
describe: Get deployment details
|
||||
patterns:
|
||||
- deployment details
|
||||
- describe deployment
|
||||
template: kubectl describe deployment {name} -n {namespace}
|
||||
explanation: Shows detailed information about a deployment.
|
||||
|
||||
- name: scale_deployment
|
||||
description: Scale a deployment
|
||||
patterns:
|
||||
- scale deployment
|
||||
- set replicas
|
||||
- kubectl scale
|
||||
template: kubectl scale deployment {name} --replicas={replicas} -n {namespace}
|
||||
explanation: Scales a deployment to the specified number of replicas.
|
||||
|
||||
- name: rollout_status
|
||||
description: Check deployment rollout status
|
||||
patterns:
|
||||
- rollout status
|
||||
- deployment status
|
||||
- kubectl rollout status
|
||||
template: kubectl rollout status deployment/{name} -n {namespace}
|
||||
explanation: Shows the rollout status of a deployment.
|
||||
|
||||
- name: rollout_restart
|
||||
description: Restart a deployment
|
||||
patterns:
|
||||
- restart deployment
|
||||
- rollout restart
|
||||
- kubectl rollout restart
|
||||
template: kubectl rollout restart deployment/{name} -n {namespace}
|
||||
explanation: Triggers a rolling restart of a deployment.
|
||||
|
||||
- name: rollout_undo
|
||||
description: Undo deployment rollout
|
||||
patterns:
|
||||
- undo rollout
|
||||
- rollback deployment
|
||||
- kubectl rollout undo
|
||||
template: kubectl rollout undo deployment/{name} -n {namespace}
|
||||
explanation: Rolls back a deployment to the previous revision.
|
||||
|
||||
- name: get_services
|
||||
description: List services
|
||||
patterns:
|
||||
- list services
|
||||
- get services
|
||||
- kubectl get services
|
||||
template: kubectl get services -n {namespace}
|
||||
explanation: Lists all services in the namespace.
|
||||
|
||||
- name: describe_service
|
||||
description: Describe a service
|
||||
patterns:
|
||||
- service details
|
||||
- describe service
|
||||
template: kubectl describe service {name} -n {namespace}
|
||||
explanation: Shows detailed information about a service.
|
||||
|
||||
- name: get_configmaps
|
||||
description: List configmaps
|
||||
patterns:
|
||||
- list configmaps
|
||||
- get configmaps
|
||||
- kubectl get configmap
|
||||
template: kubectl get configmaps -n {namespace}
|
||||
explanation: Lists all configmaps in the namespace.
|
||||
|
||||
- name: get_secrets
|
||||
description: List secrets
|
||||
patterns:
|
||||
- list secrets
|
||||
- get secrets
|
||||
- kubectl get secrets
|
||||
template: kubectl get secrets -n {namespace}
|
||||
explanation: Lists all secrets in the namespace.
|
||||
|
||||
- name: get_namespaces
|
||||
description: List namespaces
|
||||
patterns:
|
||||
- list namespaces
|
||||
- get namespaces
|
||||
- kubectl get namespaces
|
||||
template: kubectl get namespaces
|
||||
explanation: Lists all namespaces in the cluster.
|
||||
|
||||
- name: create_namespace
|
||||
description: Create a namespace
|
||||
patterns:
|
||||
- create namespace
|
||||
- new namespace
|
||||
template: kubectl create namespace {namespace}
|
||||
explanation: Creates a new namespace.
|
||||
|
||||
- name: use_namespace
|
||||
description: Set current namespace
|
||||
patterns:
|
||||
- switch namespace
|
||||
- use namespace
|
||||
- kubens
|
||||
template: kubectl config set-context --current --namespace={namespace}
|
||||
explanation: Sets the current namespace for kubectl context.
|
||||
|
||||
- name: apply_config
|
||||
description: Apply a configuration file
|
||||
patterns:
|
||||
- apply config
|
||||
- apply yaml
|
||||
- kubectl apply
|
||||
template: kubectl apply -f {file}
|
||||
explanation: Applies a configuration from a YAML file.
|
||||
|
||||
- name: apply_kustomize
|
||||
description: Apply a kustomization
|
||||
patterns:
|
||||
- apply kustomize
|
||||
- kustomize apply
|
||||
template: kubectl apply -k {directory}
|
||||
explanation: Applies a kustomization from a directory.
|
||||
|
||||
- name: get_events
|
||||
description: Get cluster events
|
||||
patterns:
|
||||
- get events
|
||||
- list events
|
||||
- kubectl get events
|
||||
template: kubectl get events --sort-by='.lastTimestamp'
|
||||
explanation: Lists all events in the cluster.
|
||||
|
||||
- name: get_nodes
|
||||
description: List cluster nodes
|
||||
patterns:
|
||||
- list nodes
|
||||
- get nodes
|
||||
- kubectl get nodes
|
||||
template: kubectl get nodes
|
||||
explanation: Lists all nodes in the cluster.
|
||||
|
||||
- name: describe_node
|
||||
description: Describe a node
|
||||
patterns:
|
||||
- node details
|
||||
- describe node
|
||||
template: kubectl describe node {node_name}
|
||||
explanation: Shows detailed information about a node.
|
||||
|
||||
- name: get_logs
|
||||
description: Get pod logs
|
||||
patterns:
|
||||
- get logs
|
||||
- pod logs
|
||||
- kubectl logs
|
||||
template: kubectl logs {pod_name} -n {namespace}
|
||||
explanation: Retrieves logs from a pod.
|
||||
|
||||
- name: get_logs_follow
|
||||
description: Follow pod logs
|
||||
patterns:
|
||||
- follow logs
|
||||
- tail logs
|
||||
- kubectl logs -f
|
||||
template: kubectl logs -f {pod_name} -n {namespace}
|
||||
explanation: Follows logs from a pod in real-time.
|
||||
|
||||
- name: get_logs_container
|
||||
description: Get logs from specific container
|
||||
patterns:
|
||||
- logs container
|
||||
- kubectl logs container
|
||||
template: kubectl logs {pod_name} -c {container} -n {namespace}
|
||||
explanation: Retrieves logs from a specific container in a pod.
|
||||
|
||||
- name: exec_pod
|
||||
description: Execute command in pod
|
||||
patterns:
|
||||
- exec into pod
|
||||
- kubectl exec
|
||||
template: kubectl exec -it {pod_name} -n {namespace} -- {command}
|
||||
explanation: Executes a command in a pod.
|
||||
|
||||
- name: port_forward
|
||||
description: Port forward to pod
|
||||
patterns:
|
||||
- port forward
|
||||
- forward port
|
||||
- kubectl port-forward
|
||||
template: kubectl port-forward {pod_name} {local_port}:{remote_port} -n {namespace}
|
||||
explanation: Forwards a local port to a pod.
|
||||
|
||||
- name: get_statefulsets
|
||||
description: List statefulsets
|
||||
patterns:
|
||||
- list statefulsets
|
||||
- get statefulsets
|
||||
template: kubectl get statefulsets -n {namespace}
|
||||
explanation: Lists all statefulsets in the namespace.
|
||||
|
||||
- name: get_ingresses
|
||||
description: List ingresses
|
||||
patterns:
|
||||
- list ingresses
|
||||
- get ingresses
|
||||
template: kubectl get ingresses -n {namespace}
|
||||
explanation: Lists all ingresses in the namespace.
|
||||
|
||||
- name: get_hpa
|
||||
description: List horizontal pod autoscalers
|
||||
patterns:
|
||||
- list hpa
|
||||
- get hpa
|
||||
template: kubectl get hpa -n {namespace}
|
||||
explanation: Lists all HPA resources in the namespace.
|
||||
|
||||
- name: top_pods
|
||||
description: Show pod resource usage
|
||||
patterns:
|
||||
- top pods
|
||||
- pod metrics
|
||||
- kubectl top pods
|
||||
template: kubectl top pods -n {namespace}
|
||||
explanation: Shows CPU and memory usage for pods.
|
||||
|
||||
- name: top_nodes
|
||||
description: Show node resource usage
|
||||
patterns:
|
||||
- top nodes
|
||||
- node metrics
|
||||
template: kubectl top nodes
|
||||
explanation: Shows CPU and memory usage for nodes.
|
||||
|
||||
- name: cluster_info
|
||||
description: Show cluster information
|
||||
patterns:
|
||||
- cluster info
|
||||
- cluster details
|
||||
template: kubectl cluster-info
|
||||
explanation: Shows information about the cluster.
|
||||
|
||||
- name: cluster_contexts
|
||||
description: List kubeconfig contexts
|
||||
patterns:
|
||||
- list contexts
|
||||
- get contexts
|
||||
template: kubectl config get-contexts
|
||||
explanation: Lists all contexts in the kubeconfig.
|
||||
|
||||
- name: current_context
|
||||
description: Show current context
|
||||
patterns:
|
||||
- current context
|
||||
- show context
|
||||
template: kubectl config current-context
|
||||
explanation: Shows the current context.
|
||||
|
||||
- name: switch_context
|
||||
description: Switch context
|
||||
patterns:
|
||||
- switch context
|
||||
- use context
|
||||
template: kubectl config use-context {context}
|
||||
explanation: Switches to the specified context.
|
||||
|
||||
- name: get_all
|
||||
description: Get all resources in namespace
|
||||
patterns:
|
||||
- get all
|
||||
- list all resources
|
||||
template: kubectl get all -n {namespace}
|
||||
explanation: Lists all resources (pods, services, deployments) in the namespace.
|
||||
|
||||
- name: diff_config
|
||||
description: Diff configuration against cluster
|
||||
patterns:
|
||||
- diff config
|
||||
- kubectl diff
|
||||
template: kubectl diff -f {file}
|
||||
explanation: Shows differences between local config and cluster config.
|
||||
|
||||
- name: explain_resource
|
||||
description: Explain resource fields
|
||||
patterns:
|
||||
- explain resource
|
||||
- kubectl explain
|
||||
template: kubectl explain {resource}
|
||||
explanation: Explains the fields of a resource.
|
||||
789
commands/unix.yaml
Normal file
789
commands/unix.yaml
Normal file
@@ -0,0 +1,789 @@
|
||||
version: "1.0"
|
||||
description: Unix command patterns
|
||||
|
||||
patterns:
|
||||
- name: list_files
|
||||
description: List directory contents
|
||||
patterns:
|
||||
- list files
|
||||
- list directory
|
||||
- ls
|
||||
- show files
|
||||
template: ls -la
|
||||
explanation: Lists all files including hidden ones with details.
|
||||
|
||||
- name: list_files_simple
|
||||
description: List files simply
|
||||
patterns:
|
||||
- simple list
|
||||
- basic ls
|
||||
template: ls
|
||||
explanation: Lists files in the current directory.
|
||||
|
||||
- name: change_directory
|
||||
description: Change directory
|
||||
patterns:
|
||||
- change directory
|
||||
- go to directory
|
||||
- cd
|
||||
template: cd {path}
|
||||
explanation: Changes the current working directory.
|
||||
|
||||
- name: go_home
|
||||
description: Go to home directory
|
||||
patterns:
|
||||
- go home
|
||||
- home directory
|
||||
template: cd ~
|
||||
explanation: Changes to the home directory.
|
||||
|
||||
- name: go_previous
|
||||
description: Go to previous directory
|
||||
patterns:
|
||||
- go back
|
||||
- previous directory
|
||||
template: cd -
|
||||
explanation: Changes to the previous working directory.
|
||||
|
||||
- name: print_working_directory
|
||||
description: Print working directory
|
||||
patterns:
|
||||
- print directory
|
||||
- pwd
|
||||
- current path
|
||||
template: pwd
|
||||
explanation: Prints the current working directory path.
|
||||
|
||||
- name: make_directory
|
||||
description: Create a directory
|
||||
patterns:
|
||||
- make directory
|
||||
- create folder
|
||||
- mkdir
|
||||
template: mkdir -p {path}
|
||||
explanation: Creates a directory (and parent directories if needed).
|
||||
|
||||
- name: remove_file
|
||||
description: Remove a file
|
||||
patterns:
|
||||
- remove file
|
||||
- delete file
|
||||
- rm
|
||||
template: rm {file}
|
||||
explanation: Removes a file.
|
||||
|
||||
- name: remove_directory
|
||||
description: Remove a directory
|
||||
patterns:
|
||||
- remove directory
|
||||
- delete folder
|
||||
- rmdir
|
||||
template: rm -rf {path}
|
||||
explanation: Removes a directory and its contents.
|
||||
|
||||
- name: copy_file
|
||||
description: Copy a file
|
||||
patterns:
|
||||
- copy file
|
||||
- cp
|
||||
template: cp {source} {destination}
|
||||
explanation: Copies a file to the destination.
|
||||
|
||||
- name: copy_directory
|
||||
description: Copy a directory
|
||||
patterns:
|
||||
- copy directory
|
||||
- cp -r
|
||||
template: cp -r {source} {destination}
|
||||
explanation: Copies a directory recursively.
|
||||
|
||||
- name: move_file
|
||||
description: Move or rename a file
|
||||
patterns:
|
||||
- move file
|
||||
- rename file
|
||||
- mv
|
||||
template: mv {source} {destination}
|
||||
explanation: Moves or renames a file or directory.
|
||||
|
||||
- name: view_file
|
||||
description: View file contents
|
||||
patterns:
|
||||
- view file
|
||||
- cat
|
||||
- show file
|
||||
template: cat {file}
|
||||
explanation: Displays file contents.
|
||||
|
||||
- name: view_file_paged
|
||||
description: View file with paging
|
||||
patterns:
|
||||
- less file
|
||||
- more file
|
||||
template: less {file}
|
||||
explanation: Views file with scroll capability.
|
||||
|
||||
- name: head_file
|
||||
description: View file head
|
||||
patterns:
|
||||
- head file
|
||||
- first lines
|
||||
template: head -n {lines} {file}
|
||||
explanation: Shows the first N lines of a file.
|
||||
|
||||
- name: tail_file
|
||||
description: View file tail
|
||||
patterns:
|
||||
- tail file
|
||||
- last lines
|
||||
template: tail -n {lines} {file}
|
||||
explanation: Shows the last N lines of a file.
|
||||
|
||||
- name: follow_tail
|
||||
description: Follow file changes
|
||||
patterns:
|
||||
- follow tail
|
||||
- tail -f
|
||||
template: tail -f {file}
|
||||
explanation: Shows the last lines of a file and follows changes.
|
||||
|
||||
- name: search_file
|
||||
description: Search for text in files
|
||||
patterns:
|
||||
- search text
|
||||
- grep
|
||||
- find text
|
||||
template: grep -r "{pattern}" .
|
||||
explanation: Searches for a pattern recursively in files.
|
||||
|
||||
- name: search_case_insensitive
|
||||
description: Search case-insensitively
|
||||
patterns:
|
||||
- search case insensitive
|
||||
- grep -i
|
||||
template: grep -ri "{pattern}" .
|
||||
explanation: Searches for a pattern case-insensitively.
|
||||
|
||||
- name: search_files_only
|
||||
description: List matching files only
|
||||
patterns:
|
||||
- find files with text
|
||||
- grep -l
|
||||
template: grep -rl "{pattern}" .
|
||||
explanation: Lists files containing the pattern.
|
||||
|
||||
- name: search_count
|
||||
description: Count matching lines
|
||||
patterns:
|
||||
- count matches
|
||||
- grep -c
|
||||
template: grep -rc "{pattern}" .
|
||||
explanation: Counts lines matching the pattern.
|
||||
|
||||
- name: find_files
|
||||
description: Find files by name
|
||||
patterns:
|
||||
- find file
|
||||
- locate file
|
||||
template: find . -name "{pattern}"
|
||||
explanation: Finds files by name pattern.
|
||||
|
||||
- name: find_files_type
|
||||
description: Find files by type
|
||||
patterns:
|
||||
- find by type
|
||||
- find directories
|
||||
template: find . -type {type}
|
||||
explanation: Finds files of a specific type (f=file, d=directory).
|
||||
|
||||
- name: find_executable
|
||||
description: Find executable
|
||||
patterns:
|
||||
- which command
|
||||
- locate executable
|
||||
template: which {command}
|
||||
explanation: Shows the location of a command.
|
||||
|
||||
- name: find_executable_all
|
||||
description: Find all executables
|
||||
patterns:
|
||||
- whereis command
|
||||
- find binary
|
||||
template: whereis {command}
|
||||
explanation: Shows binary, source, and manual locations.
|
||||
|
||||
- name: file_info
|
||||
description: Show file information
|
||||
patterns:
|
||||
- file info
|
||||
- file type
|
||||
template: file {file}
|
||||
explanation: Shows file type information.
|
||||
|
||||
- name: disk_usage
|
||||
description: Show disk usage
|
||||
patterns:
|
||||
- disk usage
|
||||
- du
|
||||
template: du -sh {path}
|
||||
explanation: Shows disk usage of a directory.
|
||||
|
||||
- name: disk_usage_all
|
||||
description: Show disk usage for all
|
||||
patterns:
|
||||
- disk usage all
|
||||
- du -h
|
||||
template: du -h
|
||||
explanation: Shows disk usage for all directories.
|
||||
|
||||
- name: disk_usage_sorted
|
||||
description: Show disk usage sorted
|
||||
patterns:
|
||||
- du sorted
|
||||
- largest directories
|
||||
template: du -h | sort -rh | head -n {n}
|
||||
explanation: Shows largest directories sorted by size.
|
||||
|
||||
- name: free_memory
|
||||
description: Show memory usage
|
||||
patterns:
|
||||
- memory usage
|
||||
- free memory
|
||||
template: free -h
|
||||
explanation: Shows memory and swap usage.
|
||||
|
||||
- name: cpu_info
|
||||
description: Show CPU info
|
||||
patterns:
|
||||
- cpu info
|
||||
- processor info
|
||||
template: lscpu
|
||||
explanation: Shows detailed CPU information.
|
||||
|
||||
- name: process_list
|
||||
description: List processes
|
||||
patterns:
|
||||
- list processes
|
||||
- show processes
|
||||
- ps
|
||||
template: ps aux
|
||||
explanation: Lists all running processes.
|
||||
|
||||
- name: process_tree
|
||||
description: List process tree
|
||||
patterns:
|
||||
- process tree
|
||||
- pstree
|
||||
template: pstree -p
|
||||
explanation: Shows processes in a tree format.
|
||||
|
||||
- name: kill_process
|
||||
description: Kill a process
|
||||
patterns:
|
||||
- kill process
|
||||
- terminate process
|
||||
template: kill {pid}
|
||||
explanation: Sends a termination signal to a process.
|
||||
|
||||
- name: kill_force
|
||||
description: Force kill a process
|
||||
patterns:
|
||||
- kill -9
|
||||
- force kill
|
||||
template: kill -9 {pid}
|
||||
explanation: Forcefully kills a process.
|
||||
|
||||
- name: top_processes
|
||||
description: Show top processes
|
||||
patterns:
|
||||
- top processes
|
||||
- htop
|
||||
template: htop
|
||||
explanation: Shows interactive process viewer (use top if htop not available).
|
||||
|
||||
- name: network_status
|
||||
description: Show network status
|
||||
patterns:
|
||||
- network status
|
||||
- netstat
|
||||
template: netstat -tuln
|
||||
explanation: Shows listening network ports.
|
||||
|
||||
- name: connections
|
||||
description: Show network connections
|
||||
patterns:
|
||||
- network connections
|
||||
- ss
|
||||
template: ss -tuln
|
||||
explanation: Shows network socket statistics.
|
||||
|
||||
- name: ping_host
|
||||
description: Ping a host
|
||||
patterns:
|
||||
- ping host
|
||||
- test connectivity
|
||||
template: ping -c {count} {host}
|
||||
explanation: Sends packets to test connectivity.
|
||||
|
||||
- name: trace_route
|
||||
description: Trace route to host
|
||||
patterns:
|
||||
- trace route
|
||||
- traceroute
|
||||
template: traceroute {host}
|
||||
explanation: Shows the route to a host.
|
||||
|
||||
- name: download_file
|
||||
description: Download a file
|
||||
patterns:
|
||||
- download file
|
||||
- wget
|
||||
template: wget {url}
|
||||
explanation: Downloads a file from URL.
|
||||
|
||||
- name: download_curl
|
||||
description: Download with curl
|
||||
patterns:
|
||||
- curl download
|
||||
template: curl -O {url}
|
||||
explanation: Downloads a file using curl.
|
||||
|
||||
- name: curl_headers
|
||||
description: Get HTTP headers
|
||||
patterns:
|
||||
- check headers
|
||||
- curl head
|
||||
template: curl -I {url}
|
||||
explanation: Shows HTTP response headers.
|
||||
|
||||
- name: ssh_connect
|
||||
description: Connect via SSH
|
||||
patterns:
|
||||
- ssh connect
|
||||
- connect to server
|
||||
template: ssh {user}@{host}
|
||||
explanation: Connects to a host via SSH.
|
||||
|
||||
- name: ssh_with_key
|
||||
description: SSH with specific key
|
||||
patterns:
|
||||
- ssh with key
|
||||
- ssh -i
|
||||
template: ssh -i {key_file} {user}@{host}
|
||||
explanation: Connects using a specific SSH key.
|
||||
|
||||
- name: scp_copy
|
||||
description: Copy over SSH
|
||||
patterns:
|
||||
- scp copy
|
||||
- secure copy
|
||||
template: scp {source} {user}@{host}:{path}
|
||||
explanation: Copies files over SSH.
|
||||
|
||||
- name: sync_files
|
||||
description: Sync files with rsync
|
||||
patterns:
|
||||
- rsync
|
||||
- sync directories
|
||||
template: rsync -avz {source} {destination}
|
||||
explanation: Synchronizes directories efficiently.
|
||||
|
||||
- name: change_permissions
|
||||
description: Change file permissions
|
||||
patterns:
|
||||
- chmod
|
||||
- change permissions
|
||||
template: chmod {mode} {file}
|
||||
explanation: Changes file permissions (e.g., 755, +x).
|
||||
|
||||
- name: change_owner
|
||||
description: Change file owner
|
||||
patterns:
|
||||
- chown
|
||||
- change owner
|
||||
template: chown {user}:{group} {file}
|
||||
explanation: Changes file owner and group.
|
||||
|
||||
- name: change_group
|
||||
description: Change file group
|
||||
patterns:
|
||||
- change group
|
||||
- chgrp
|
||||
template: chgrp {group} {file}
|
||||
explanation: Changes file group.
|
||||
|
||||
- name: compress_tar
|
||||
description: Create tar archive
|
||||
patterns:
|
||||
- tar compress
|
||||
- create tar
|
||||
template: tar -czvf {archive}.tar.gz {path}
|
||||
explanation: Creates a compressed tar archive.
|
||||
|
||||
- name: extract_tar
|
||||
description: Extract tar archive
|
||||
patterns:
|
||||
- extract tar
|
||||
- untar
|
||||
template: tar -xzvf {archive}.tar.gz
|
||||
explanation: Extracts a tar archive.
|
||||
|
||||
- name: list_tar
|
||||
description: List tar contents
|
||||
patterns:
|
||||
- list tar
|
||||
- tar -t
|
||||
template: tar -tzvf {archive}.tar.gz
|
||||
explanation: Lists contents of a tar archive.
|
||||
|
||||
- name: create_zip
|
||||
description: Create zip archive
|
||||
patterns:
|
||||
- zip file
|
||||
- create zip
|
||||
template: zip -r {archive}.zip {path}
|
||||
explanation: Creates a zip archive.
|
||||
|
||||
- name: extract_zip
|
||||
description: Extract zip archive
|
||||
patterns:
|
||||
- unzip
|
||||
- extract zip
|
||||
template: unzip {archive}.zip
|
||||
explanation: Extracts a zip archive.
|
||||
|
||||
- name: list_zip
|
||||
description: List zip contents
|
||||
patterns:
|
||||
- list zip
|
||||
- unzip -l
|
||||
template: unzip -l {archive}.zip
|
||||
explanation: Lists contents of a zip archive.
|
||||
|
||||
- name: show_date
|
||||
description: Show current date
|
||||
patterns:
|
||||
- current date
|
||||
- date
|
||||
template: date
|
||||
explanation: Shows current date and time.
|
||||
|
||||
- name: show_calendar
|
||||
description: Show calendar
|
||||
patterns:
|
||||
- calendar
|
||||
- cal
|
||||
template: cal
|
||||
explanation: Shows a calendar.
|
||||
|
||||
- name: show_calendar_year
|
||||
description: Show calendar for year
|
||||
patterns:
|
||||
- calendar year
|
||||
- cal year
|
||||
template: cal -y
|
||||
explanation: Shows calendar for the entire year.
|
||||
|
||||
- name: whoami
|
||||
description: Show current user
|
||||
patterns:
|
||||
- current user
|
||||
- who am i
|
||||
template: whoami
|
||||
explanation: Shows the current username.
|
||||
|
||||
- name: hostname
|
||||
description: Show hostname
|
||||
patterns:
|
||||
- hostname
|
||||
- machine name
|
||||
template: hostname
|
||||
explanation: Shows the machine hostname.
|
||||
|
||||
- name: uname
|
||||
description: Show system info
|
||||
patterns:
|
||||
- system info
|
||||
- uname
|
||||
template: uname -a
|
||||
explanation: Shows all system information.
|
||||
|
||||
- name: environment
|
||||
description: Show environment variables
|
||||
patterns:
|
||||
- environment
|
||||
- env
|
||||
template: env
|
||||
explanation: Shows all environment variables.
|
||||
|
||||
- name: echo_variable
|
||||
description: Echo environment variable
|
||||
patterns:
|
||||
- echo env
|
||||
- show variable
|
||||
template: echo ${VAR}
|
||||
explanation: Shows the value of an environment variable.
|
||||
|
||||
- name: set_variable
|
||||
description: Set environment variable
|
||||
patterns:
|
||||
- export variable
|
||||
- set env
|
||||
template: export VAR=value
|
||||
explanation: Sets an environment variable.
|
||||
|
||||
- name: add_path
|
||||
description: Add to PATH
|
||||
patterns:
|
||||
- add to path
|
||||
- PATH export
|
||||
template: export PATH=$PATH:{path}
|
||||
explanation: Adds a directory to PATH.
|
||||
|
||||
- name: show_man_page
|
||||
description: Show manual page
|
||||
patterns:
|
||||
- man page
|
||||
- manual
|
||||
template: man {command}
|
||||
explanation: Shows the manual page for a command.
|
||||
|
||||
- name: show_help
|
||||
description: Show command help
|
||||
patterns:
|
||||
- command help
|
||||
- --help
|
||||
template: "{command} --help"
|
||||
explanation: Shows help for a command.
|
||||
|
||||
- name: show_builtin_help
|
||||
description: Show shell builtin help
|
||||
patterns:
|
||||
- builtin help
|
||||
- help command
|
||||
template: help {command}
|
||||
explanation: Shows help for a shell builtin.
|
||||
|
||||
- name: locate_file
|
||||
description: Locate files quickly
|
||||
patterns:
|
||||
- locate
|
||||
- find quickly
|
||||
template: locate {pattern}
|
||||
explanation: Searches for files using a database (updatedb first if needed).
|
||||
|
||||
- name: updatedb
|
||||
description: Update locate database
|
||||
patterns:
|
||||
- update locate
|
||||
- updatedb
|
||||
template: sudo updatedb
|
||||
explanation: Updates the file database for locate.
|
||||
|
||||
- name: sort_file
|
||||
description: Sort file contents
|
||||
patterns:
|
||||
- sort file
|
||||
- sort lines
|
||||
template: sort {file}
|
||||
explanation: Sorts file contents.
|
||||
|
||||
- name: sort_numeric
|
||||
description: Sort numerically
|
||||
patterns:
|
||||
- sort numbers
|
||||
- sort -n
|
||||
template: sort -n {file}
|
||||
explanation: Sorts file contents numerically.
|
||||
|
||||
- name: unique_lines
|
||||
description: Remove duplicate lines
|
||||
patterns:
|
||||
- unique
|
||||
- uniq
|
||||
template: sort {file} | uniq
|
||||
explanation: Removes duplicate lines from sorted input.
|
||||
|
||||
- name: count_lines
|
||||
description: Count lines
|
||||
patterns:
|
||||
- line count
|
||||
- wc -l
|
||||
template: wc -l {file}
|
||||
explanation: Counts the number of lines in a file.
|
||||
|
||||
- name: count_words
|
||||
description: Count words
|
||||
patterns:
|
||||
- word count
|
||||
- wc
|
||||
template: wc {file}
|
||||
explanation: Counts lines, words, and characters in a file.
|
||||
|
||||
- name: word_count
|
||||
description: Count occurrences
|
||||
patterns:
|
||||
- count occurrences
|
||||
- wc -c
|
||||
template: wc -c {file}
|
||||
explanation: Counts characters or bytes in a file.
|
||||
|
||||
- name: cut_columns
|
||||
description: Cut columns from file
|
||||
patterns:
|
||||
- cut columns
|
||||
- cut fields
|
||||
template: cut -d'{delimiter}' -f{fields} {file}
|
||||
explanation: Extracts specific columns from a delimited file.
|
||||
|
||||
- name: paste_columns
|
||||
description: Paste columns
|
||||
patterns:
|
||||
- paste columns
|
||||
- merge columns
|
||||
template: paste {file1} {file2}
|
||||
explanation: Merges lines of files horizontally.
|
||||
|
||||
- name: join_files
|
||||
description: Join files
|
||||
patterns:
|
||||
- join files
|
||||
- join fields
|
||||
template: join {file1} {file2}
|
||||
explanation: Joins lines of two files on a common field.
|
||||
|
||||
- name: compare_files
|
||||
description: Compare files
|
||||
patterns:
|
||||
- compare files
|
||||
- diff
|
||||
template: diff {file1} {file2}
|
||||
explanation: Shows differences between two files.
|
||||
|
||||
- name: compare_side_by_side
|
||||
description: Side by side comparison
|
||||
patterns:
|
||||
- side by side diff
|
||||
- diff -y
|
||||
template: diff -y {file1} {file2}
|
||||
explanation: Shows differences side by side.
|
||||
|
||||
- name: patch_file
|
||||
description: Apply patch
|
||||
patterns:
|
||||
- apply patch
|
||||
- patch
|
||||
template: patch -p1 < {patch_file}
|
||||
explanation: Applies a patch to files.
|
||||
|
||||
- name: stream_editor
|
||||
description: Stream editor
|
||||
patterns:
|
||||
- sed substitute
|
||||
- sed replace
|
||||
template: sed -i 's/{old}/{new}/g' {file}
|
||||
explanation: Replaces text in a file using sed.
|
||||
|
||||
- name: awk_print
|
||||
description: Process with awk
|
||||
patterns:
|
||||
- awk print
|
||||
- awk process
|
||||
template: awk '{print ${column}}' {file}
|
||||
explanation: Extracts and prints specific columns.
|
||||
|
||||
- name: xargs
|
||||
description: Build and execute commands
|
||||
patterns:
|
||||
- xargs
|
||||
- pipe to command
|
||||
template: find . -name "{pattern}" | xargs {command}
|
||||
explanation: Builds and executes commands from standard input.
|
||||
|
||||
- name: tee_output
|
||||
description: Split output
|
||||
patterns:
|
||||
- tee
|
||||
- save and display
|
||||
template: "{command} | tee {file}"
|
||||
explanation: Saves output to a file while displaying it.
|
||||
|
||||
- name: nohup_command
|
||||
description: Run command immune to hangups
|
||||
patterns:
|
||||
- nohup
|
||||
- run in background
|
||||
template: nohup {command} > {output} 2>&1 &
|
||||
explanation: Runs a command immune to hangups in background.
|
||||
|
||||
- name: screen_create
|
||||
description: Create a screen session
|
||||
patterns:
|
||||
- create screen
|
||||
- screen new
|
||||
template: screen -S {name}
|
||||
explanation: Creates a new detached screen session.
|
||||
|
||||
- name: screen_list
|
||||
description: List screen sessions
|
||||
patterns:
|
||||
- screen list
|
||||
- screen -ls
|
||||
template: screen -ls
|
||||
explanation: Lists all screen sessions.
|
||||
|
||||
- name: screen_attach
|
||||
description: Attach to screen
|
||||
patterns:
|
||||
- attach screen
|
||||
- screen -r
|
||||
template: screen -r {name}
|
||||
explanation: Attaches to a screen session.
|
||||
|
||||
- name: tmux_create
|
||||
description: Create a tmux session
|
||||
patterns:
|
||||
- create tmux
|
||||
- tmux new
|
||||
template: tmux new -s {name}
|
||||
explanation: Creates a new tmux session.
|
||||
|
||||
- name: tmux_list
|
||||
description: List tmux sessions
|
||||
patterns:
|
||||
- tmux list
|
||||
- tmux ls
|
||||
template: tmux ls
|
||||
explanation: Lists all tmux sessions.
|
||||
|
||||
- name: tmux_attach
|
||||
description: Attach to tmux
|
||||
patterns:
|
||||
- attach tmux
|
||||
- tmux attach
|
||||
template: tmux attach -t {name}
|
||||
explanation: Attaches to a tmux session.
|
||||
|
||||
- name: alias_create
|
||||
description: Create an alias
|
||||
patterns:
|
||||
- create alias
|
||||
- alias
|
||||
template: alias {name}='{command}'
|
||||
explanation: Creates a shell alias.
|
||||
|
||||
- name: source_file
|
||||
description: Source a file
|
||||
patterns:
|
||||
- source file
|
||||
- . file
|
||||
template: source {file}
|
||||
explanation: Executes commands from a file in current shell.
|
||||
|
||||
- name: export_function
|
||||
description: Export a function
|
||||
patterns:
|
||||
- export function
|
||||
- export -f
|
||||
template: export -f {function_name}
|
||||
explanation: Exports a shell function to child shells.
|
||||
BIN
data/7000auto.db
Normal file
BIN
data/7000auto.db
Normal file
Binary file not shown.
65
pyproject.toml
Normal file
65
pyproject.toml
Normal file
@@ -0,0 +1,65 @@
|
||||
[build-system]
|
||||
requires = ["setuptools>=61.0", "wheel"]
|
||||
build-backend = "setuptools.build_meta"
|
||||
|
||||
[project]
|
||||
name = "shell-speak"
|
||||
version = "0.1.0"
|
||||
description = "A CLI tool that converts natural language descriptions into shell commands"
|
||||
readme = "README.md"
|
||||
license = {text = "MIT"}
|
||||
requires-python = ">=3.10"
|
||||
authors = [
|
||||
{name = "Shell Speak Contributors"}
|
||||
]
|
||||
keywords = ["cli", "shell", "docker", "kubectl", "git", "unix", "natural-language"]
|
||||
classifiers = [
|
||||
"Development Status :: 4 - Beta",
|
||||
"Intended Audience :: Developers",
|
||||
"License :: OSI Approved :: MIT License",
|
||||
"Programming Language :: Python :: 3",
|
||||
"Programming Language :: Python :: 3.10",
|
||||
"Programming Language :: Python :: 3.11",
|
||||
"Programming Language :: Python :: 3.12",
|
||||
]
|
||||
dependencies = [
|
||||
"typer>=0.9.0",
|
||||
"rich>=13.0.0",
|
||||
"shellingham>=1.5.0",
|
||||
"prompt-toolkit>=3.0.0",
|
||||
"pyyaml>=6.0",
|
||||
]
|
||||
|
||||
[project.optional-dependencies]
|
||||
dev = [
|
||||
"pytest>=7.0.0",
|
||||
"pytest-cov>=4.0.0",
|
||||
]
|
||||
|
||||
[project.scripts]
|
||||
shell-speak = "shell_speak.main:main"
|
||||
|
||||
[tool.setuptools.packages.find]
|
||||
where = ["shell_speak"]
|
||||
include = ["shell_speak*"]
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
testpaths = ["tests"]
|
||||
python_files = ["test_*.py"]
|
||||
python_functions = ["test_*"]
|
||||
addopts = "-v --tb=short"
|
||||
|
||||
[tool.ruff]
|
||||
line-length = 100
|
||||
target-version = "py310"
|
||||
|
||||
[tool.ruff.lint]
|
||||
select = ["E", "F", "W", "C90", "I", "N", "UP"]
|
||||
ignore = ["E501"]
|
||||
|
||||
[tool.ruff.lint.per-file-ignores]
|
||||
"tests/__init__.py" = ["F401", "I001"]
|
||||
"tests/conftest.py" = ["F401", "I001"]
|
||||
|
||||
[tool.ruff.lint.isort]
|
||||
known-first-party = ["shell_speak"]
|
||||
7
requirements.txt
Normal file
7
requirements.txt
Normal file
@@ -0,0 +1,7 @@
|
||||
typer>=0.9.0
|
||||
rich>=13.0.0
|
||||
shellingham>=1.5.0
|
||||
prompt-toolkit>=3.0.0
|
||||
pyyaml>=6.0
|
||||
pytest>=7.0.0
|
||||
pytest-cov>=4.0.0
|
||||
3
shell_speak/__init__.py
Normal file
3
shell_speak/__init__.py
Normal file
@@ -0,0 +1,3 @@
|
||||
"""Shell Speak - Convert natural language to shell commands."""
|
||||
|
||||
__version__ = "0.1.0"
|
||||
29
shell_speak/config.py
Normal file
29
shell_speak/config.py
Normal file
@@ -0,0 +1,29 @@
|
||||
"""Configuration module for shell-speak."""
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def get_data_dir() -> Path:
|
||||
"""Get the data directory for shell-speak."""
|
||||
return Path(os.environ.get("SHELL_SPEAK_DATA_DIR", "~/.local/share/shell-speak")).expanduser()
|
||||
|
||||
|
||||
def get_history_file() -> Path:
|
||||
"""Get the path to the command history file."""
|
||||
return Path(os.environ.get("SHELL_SPEAK_HISTORY_FILE", "~/.local/share/shell-speak/history.json")).expanduser()
|
||||
|
||||
|
||||
def get_corrections_file() -> Path:
|
||||
"""Get the path to the user corrections file."""
|
||||
return Path(os.environ.get("SHELL_SPEAK_CORRECTIONS_FILE", "~/.local/share/shell-speak/corrections.json")).expanduser()
|
||||
|
||||
|
||||
def ensure_data_dir() -> Path:
|
||||
"""Ensure the data directory exists."""
|
||||
data_dir = get_data_dir()
|
||||
data_dir.mkdir(parents=True, exist_ok=True)
|
||||
return data_dir
|
||||
|
||||
|
||||
DEFAULT_TOOLS = ["docker", "kubectl", "git", "unix"]
|
||||
136
shell_speak/history.py
Normal file
136
shell_speak/history.py
Normal file
@@ -0,0 +1,136 @@
|
||||
"""History management module."""
|
||||
|
||||
import json
|
||||
from datetime import datetime
|
||||
|
||||
from shell_speak.config import ensure_data_dir, get_history_file
|
||||
from shell_speak.models import HistoryEntry
|
||||
|
||||
|
||||
class HistoryManager:
|
||||
"""Manages command history storage and retrieval."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._entries: list[HistoryEntry] = []
|
||||
self._loaded = False
|
||||
|
||||
def load(self) -> None:
|
||||
"""Load history from file."""
|
||||
history_file = get_history_file()
|
||||
if not history_file.exists():
|
||||
self._entries = []
|
||||
self._loaded = True
|
||||
return
|
||||
|
||||
try:
|
||||
with open(history_file) as f:
|
||||
data = json.load(f)
|
||||
self._entries = []
|
||||
for item in data.get("entries", []):
|
||||
entry = HistoryEntry(
|
||||
query=item.get("query", ""),
|
||||
command=item.get("command", ""),
|
||||
tool=item.get("tool", ""),
|
||||
timestamp=datetime.fromisoformat(item.get("timestamp", datetime.now().isoformat())),
|
||||
explanation=item.get("explanation", ""),
|
||||
)
|
||||
self._entries.append(entry)
|
||||
except Exception:
|
||||
self._entries = []
|
||||
|
||||
self._loaded = True
|
||||
|
||||
def save(self) -> None:
|
||||
"""Save history to file."""
|
||||
ensure_data_dir()
|
||||
history_file = get_history_file()
|
||||
|
||||
data = {
|
||||
"version": "1.0",
|
||||
"entries": [
|
||||
{
|
||||
"query": entry.query,
|
||||
"command": entry.command,
|
||||
"tool": entry.tool,
|
||||
"timestamp": entry.timestamp.isoformat(),
|
||||
"explanation": entry.explanation,
|
||||
}
|
||||
for entry in self._entries
|
||||
],
|
||||
}
|
||||
|
||||
with open(history_file, 'w') as f:
|
||||
json.dump(data, f, indent=2)
|
||||
|
||||
def add(self, query: str, command: str, tool: str, explanation: str = "") -> None:
|
||||
"""Add a new entry to history."""
|
||||
if not self._loaded:
|
||||
self.load()
|
||||
|
||||
entry = HistoryEntry(
|
||||
query=query,
|
||||
command=command,
|
||||
tool=tool,
|
||||
timestamp=datetime.now(),
|
||||
explanation=explanation,
|
||||
)
|
||||
self._entries.append(entry)
|
||||
|
||||
if len(self._entries) > 1000:
|
||||
self._entries = self._entries[-1000:]
|
||||
|
||||
self.save()
|
||||
|
||||
def get_all(self) -> list[HistoryEntry]:
|
||||
"""Get all history entries."""
|
||||
if not self._loaded:
|
||||
self.load()
|
||||
return self._entries.copy()
|
||||
|
||||
def get_recent(self, limit: int = 20) -> list[HistoryEntry]:
|
||||
"""Get recent history entries."""
|
||||
if not self._loaded:
|
||||
self.load()
|
||||
return self._entries[-limit:]
|
||||
|
||||
def search(self, query: str, tool: str | None = None) -> list[HistoryEntry]:
|
||||
"""Search history entries."""
|
||||
if not self._loaded:
|
||||
self.load()
|
||||
|
||||
results = []
|
||||
query_lower = query.lower()
|
||||
|
||||
for entry in self._entries:
|
||||
if query_lower in entry.query.lower() or query_lower in entry.command.lower():
|
||||
if tool is None or entry.tool == tool:
|
||||
results.append(entry)
|
||||
|
||||
return results
|
||||
|
||||
def get_last_command(self, tool: str | None = None) -> HistoryEntry | None:
|
||||
"""Get the last command from history."""
|
||||
if not self._loaded:
|
||||
self.load()
|
||||
|
||||
for entry in reversed(self._entries):
|
||||
if tool is None or entry.tool == tool:
|
||||
return entry
|
||||
|
||||
return None
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Clear all history."""
|
||||
self._entries = []
|
||||
self.save()
|
||||
|
||||
|
||||
_history_manager: HistoryManager | None = None
|
||||
|
||||
|
||||
def get_history_manager() -> HistoryManager:
|
||||
"""Get the global history manager."""
|
||||
global _history_manager
|
||||
if _history_manager is None:
|
||||
_history_manager = HistoryManager()
|
||||
return _history_manager
|
||||
240
shell_speak/interactive.py
Normal file
240
shell_speak/interactive.py
Normal file
@@ -0,0 +1,240 @@
|
||||
"""Interactive mode implementation."""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
from collections.abc import Generator
|
||||
|
||||
from prompt_toolkit import PromptSession
|
||||
from prompt_toolkit.completion import Completer, Completion
|
||||
from prompt_toolkit.document import Document
|
||||
from prompt_toolkit.history import FileHistory
|
||||
from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
|
||||
from prompt_toolkit.keys import Keys
|
||||
|
||||
from shell_speak.config import ensure_data_dir, get_data_dir
|
||||
from shell_speak.history import get_history_manager
|
||||
from shell_speak.library import get_loader
|
||||
from shell_speak.matcher import get_matcher
|
||||
from shell_speak.models import CommandMatch
|
||||
from shell_speak.output import (
|
||||
console,
|
||||
display_command,
|
||||
display_error,
|
||||
display_help_header,
|
||||
display_history,
|
||||
)
|
||||
|
||||
|
||||
class ShellSpeakCompleter(Completer):
|
||||
"""Auto-completion for shell-speak."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._loader = get_loader()
|
||||
self._history_manager = get_history_manager()
|
||||
|
||||
def get_completions(
|
||||
self, document: Document, complete_event: object
|
||||
) -> Generator[Completion, None, None]:
|
||||
text = document.text_before_cursor
|
||||
last_word = text.split()[-1] if text.split() else ""
|
||||
|
||||
history = self._history_manager.get_recent(50)
|
||||
for entry in reversed(history):
|
||||
if entry.query.lower().startswith(last_word.lower()):
|
||||
yield Completion(
|
||||
entry.query,
|
||||
start_position=-len(last_word),
|
||||
style="fg:cyan",
|
||||
)
|
||||
|
||||
patterns = self._loader.get_patterns()
|
||||
for pattern in patterns:
|
||||
for ptn in pattern.patterns:
|
||||
if ptn.lower().startswith(last_word.lower()):
|
||||
yield Completion(
|
||||
ptn,
|
||||
start_position=-len(last_word),
|
||||
style="fg:green",
|
||||
)
|
||||
|
||||
|
||||
def create_key_bindings() -> KeyBindings:
|
||||
"""Create key bindings for interactive mode."""
|
||||
kb = KeyBindings()
|
||||
|
||||
@kb.add(Keys.ControlC)
|
||||
def _(event: KeyPressEvent) -> None:
|
||||
event.app.exit()
|
||||
|
||||
@kb.add(Keys.ControlL)
|
||||
def _(event: KeyPressEvent) -> None:
|
||||
os.system("clear" if os.name == "posix" else "cls")
|
||||
|
||||
return kb
|
||||
|
||||
|
||||
def get_terminal_size() -> tuple[int, int]:
|
||||
"""Get terminal size."""
|
||||
return shutil.get_terminal_size()
|
||||
|
||||
|
||||
def run_interactive_mode() -> None: # noqa: C901
|
||||
"""Run the interactive shell mode."""
|
||||
ensure_data_dir()
|
||||
|
||||
display_help_header()
|
||||
|
||||
history_file = get_data_dir() / ".history"
|
||||
session: PromptSession[str] = PromptSession(
|
||||
history=FileHistory(str(history_file)),
|
||||
completer=ShellSpeakCompleter(),
|
||||
key_bindings=create_key_bindings(),
|
||||
complete_while_typing=True,
|
||||
enable_history_search=True,
|
||||
)
|
||||
|
||||
history_manager = get_history_manager()
|
||||
history_manager.load()
|
||||
|
||||
loader = get_loader()
|
||||
loader.load_library()
|
||||
|
||||
console.print("\n[info]Interactive mode started. Type 'help' for commands, 'exit' to quit.[/]\n")
|
||||
|
||||
while True:
|
||||
try:
|
||||
user_input = session.prompt(
|
||||
"[shell-speak]>> ",
|
||||
multiline=False,
|
||||
).strip()
|
||||
except KeyboardInterrupt:
|
||||
console.print("\n[info]Use 'exit' to quit.[/]")
|
||||
continue
|
||||
except EOFError:
|
||||
break
|
||||
|
||||
if not user_input:
|
||||
continue
|
||||
|
||||
if user_input.lower() in ("exit", "quit", "q"):
|
||||
break
|
||||
|
||||
if user_input.lower() == "help":
|
||||
_show_interactive_help()
|
||||
continue
|
||||
|
||||
if user_input.lower() == "clear":
|
||||
os.system("clear" if os.name == "posix" else "cls")
|
||||
continue
|
||||
|
||||
if user_input.lower() == "history":
|
||||
entries = history_manager.get_recent(50)
|
||||
display_history(entries)
|
||||
continue
|
||||
|
||||
if user_input.startswith("learn "):
|
||||
parts = user_input[6:].split("::")
|
||||
if len(parts) >= 2:
|
||||
query, command = parts[0].strip(), parts[1].strip()
|
||||
tool = parts[2].strip() if len(parts) > 2 else "custom"
|
||||
loader.add_correction(query, command, tool)
|
||||
console.print(f"[success]Learned: {query} -> {command}[/]")
|
||||
else:
|
||||
console.print("[error]Usage: learn <query>::<command>::<tool>[/]")
|
||||
continue
|
||||
|
||||
if user_input.startswith("forget "):
|
||||
query = user_input[7:].strip()
|
||||
tool = "custom"
|
||||
if loader.remove_correction(query, tool):
|
||||
console.print(f"[success]Forgot: {query}[/]")
|
||||
else:
|
||||
console.print(f"[warning]Pattern not found: {query}[/]")
|
||||
continue
|
||||
|
||||
if user_input.startswith("repeat"):
|
||||
parts = user_input.split()
|
||||
if len(parts) > 1:
|
||||
try:
|
||||
idx = int(parts[1])
|
||||
entries = history_manager.get_recent(100)
|
||||
if 1 <= idx <= len(entries):
|
||||
entry = entries[-idx]
|
||||
console.print(f"[info]Repeating command {idx} entries ago:[/]")
|
||||
_process_query(entry.query, entry.tool)
|
||||
else:
|
||||
console.print("[error]Invalid history index[/]")
|
||||
except ValueError:
|
||||
console.print("[error]Invalid index[/]")
|
||||
continue
|
||||
|
||||
detected_tool: str | None = _detect_tool(user_input)
|
||||
match = _process_query(user_input, detected_tool)
|
||||
|
||||
if match:
|
||||
history_manager.add(user_input, match.command, match.pattern.tool, match.explanation)
|
||||
|
||||
console.print("\n[info]Goodbye![/]")
|
||||
|
||||
|
||||
def _detect_tool(query: str) -> str | None:
|
||||
"""Detect which tool the query is about."""
|
||||
query_lower = query.lower()
|
||||
|
||||
docker_keywords = ["docker", "container", "image", "run", "build", "pull", "push", "ps", "logs"]
|
||||
kubectl_keywords = ["kubectl", "k8s", "kubernetes", "pod", "deploy", "service", "namespace", "apply"]
|
||||
git_keywords = ["git", "commit", "push", "pull", "branch", "merge", "checkout", "clone"]
|
||||
|
||||
for kw in docker_keywords:
|
||||
if kw in query_lower:
|
||||
return "docker"
|
||||
for kw in kubectl_keywords:
|
||||
if kw in query_lower:
|
||||
return "kubectl"
|
||||
for kw in git_keywords:
|
||||
if kw in query_lower:
|
||||
return "git"
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def _process_query(query: str, tool: str | None) -> CommandMatch | None:
|
||||
"""Process a user query and display the result."""
|
||||
matcher = get_matcher()
|
||||
match = matcher.match(query, tool)
|
||||
|
||||
if match and match.confidence >= 0.3:
|
||||
display_command(match, explain=False)
|
||||
return match
|
||||
else:
|
||||
display_error(f"Could not find a matching command for: '{query}'")
|
||||
console.print("[info]Try rephrasing or use 'learn' to teach me a new command.[/]")
|
||||
return None
|
||||
|
||||
|
||||
def _show_interactive_help() -> None:
|
||||
"""Show help for interactive mode."""
|
||||
help_text = """
|
||||
[bold]Shell Speak - Interactive Help[/bold]
|
||||
|
||||
[bold]Commands:[/bold]
|
||||
help Show this help message
|
||||
clear Clear the screen
|
||||
history Show command history
|
||||
repeat <n> Repeat the nth command from history (1 = most recent)
|
||||
learn <q>::<c>::<t> Learn a new command pattern
|
||||
forget <q> Forget a learned pattern
|
||||
exit Exit interactive mode
|
||||
|
||||
[bold]Examples:[/bold]
|
||||
show running containers
|
||||
commit changes with message "fix bug"
|
||||
list files in current directory
|
||||
apply kubernetes config
|
||||
|
||||
[bold]Tips:[/bold]
|
||||
- Use up/down arrows to navigate history
|
||||
- Tab to autocomplete from history
|
||||
- Corrections are saved automatically
|
||||
"""
|
||||
console.print(help_text)
|
||||
131
shell_speak/library.py
Normal file
131
shell_speak/library.py
Normal file
@@ -0,0 +1,131 @@
|
||||
"""Command library loader module."""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
import yaml
|
||||
|
||||
from shell_speak.config import get_data_dir
|
||||
from shell_speak.models import CommandPattern
|
||||
|
||||
|
||||
class CommandLibraryLoader:
|
||||
"""Loads and manages command pattern libraries."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._patterns: list[CommandPattern] = []
|
||||
self._corrections: dict[str, str] = {}
|
||||
self._loaded = False
|
||||
|
||||
def load_library(self, tool: str | None = None) -> None:
|
||||
"""Load command patterns from library files."""
|
||||
data_dir = get_data_dir()
|
||||
self._patterns = []
|
||||
|
||||
tool_files = {
|
||||
"docker": "docker.yaml",
|
||||
"kubectl": "kubectl.yaml",
|
||||
"git": "git.yaml",
|
||||
"unix": "unix.yaml",
|
||||
}
|
||||
|
||||
if tool:
|
||||
files_to_load = {tool: tool_files.get(tool, f"{tool}.yaml")}
|
||||
else:
|
||||
files_to_load = tool_files
|
||||
|
||||
for tool_name, filename in files_to_load.items():
|
||||
filepath = data_dir / filename
|
||||
if filepath.exists():
|
||||
try:
|
||||
patterns = self._load_yaml_library(filepath, tool_name)
|
||||
self._patterns.extend(patterns)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
self._load_corrections()
|
||||
self._loaded = True
|
||||
|
||||
def _load_yaml_library(self, filepath: Path, tool: str) -> list[CommandPattern]:
|
||||
"""Load patterns from a YAML file."""
|
||||
with open(filepath) as f:
|
||||
data = yaml.safe_load(f) or {}
|
||||
|
||||
patterns = []
|
||||
for item in data.get("patterns", []):
|
||||
pattern = CommandPattern(
|
||||
name=item.get("name", ""),
|
||||
tool=tool,
|
||||
description=item.get("description", ""),
|
||||
patterns=item.get("patterns", []),
|
||||
template=item.get("template", ""),
|
||||
explanation=item.get("explanation", ""),
|
||||
examples=item.get("examples", []),
|
||||
)
|
||||
patterns.append(pattern)
|
||||
|
||||
return patterns
|
||||
|
||||
def _load_corrections(self) -> None:
|
||||
"""Load user corrections from JSON file."""
|
||||
corrections_file = get_data_dir() / "corrections.json"
|
||||
if corrections_file.exists():
|
||||
try:
|
||||
with open(corrections_file) as f:
|
||||
data = json.load(f)
|
||||
self._corrections = data.get("corrections", {})
|
||||
except Exception:
|
||||
self._corrections = {}
|
||||
|
||||
def get_patterns(self) -> list[CommandPattern]:
|
||||
"""Get all loaded patterns."""
|
||||
if not self._loaded:
|
||||
self.load_library()
|
||||
return self._patterns
|
||||
|
||||
def get_corrections(self) -> dict[str, str]:
|
||||
"""Get all user corrections."""
|
||||
if not self._loaded:
|
||||
self.load_library()
|
||||
return self._corrections
|
||||
|
||||
def add_correction(self, query: str, command: str, tool: str) -> None:
|
||||
"""Add a user correction."""
|
||||
key = f"{tool}:{query.lower().strip()}"
|
||||
self._corrections[key] = command
|
||||
self._save_corrections()
|
||||
|
||||
def remove_correction(self, query: str, tool: str) -> bool:
|
||||
"""Remove a user correction."""
|
||||
key = f"{tool}:{query.lower().strip()}"
|
||||
if key in self._corrections:
|
||||
del self._corrections[key]
|
||||
self._save_corrections()
|
||||
return True
|
||||
return False
|
||||
|
||||
def _save_corrections(self) -> None:
|
||||
"""Save corrections to JSON file."""
|
||||
corrections_file = get_data_dir() / "corrections.json"
|
||||
data = {
|
||||
"version": "1.0",
|
||||
"corrections": self._corrections,
|
||||
}
|
||||
with open(corrections_file, 'w') as f:
|
||||
json.dump(data, f, indent=2)
|
||||
|
||||
def reload(self) -> None:
|
||||
"""Reload all libraries and corrections."""
|
||||
self._loaded = False
|
||||
self.load_library()
|
||||
|
||||
|
||||
_loader: CommandLibraryLoader | None = None
|
||||
|
||||
|
||||
def get_loader() -> CommandLibraryLoader:
|
||||
"""Get the global command library loader."""
|
||||
global _loader
|
||||
if _loader is None:
|
||||
_loader = CommandLibraryLoader()
|
||||
return _loader
|
||||
215
shell_speak/main.py
Normal file
215
shell_speak/main.py
Normal file
@@ -0,0 +1,215 @@
|
||||
"""Main CLI entry point for shell-speak."""
|
||||
|
||||
import sys
|
||||
|
||||
import typer
|
||||
from rich.panel import Panel
|
||||
from rich.text import Text
|
||||
|
||||
from shell_speak import __version__
|
||||
from shell_speak.config import DEFAULT_TOOLS, ensure_data_dir
|
||||
from shell_speak.history import get_history_manager
|
||||
from shell_speak.interactive import run_interactive_mode
|
||||
from shell_speak.library import get_loader
|
||||
from shell_speak.matcher import get_matcher
|
||||
from shell_speak.output import (
|
||||
console,
|
||||
display_command,
|
||||
display_error,
|
||||
display_history,
|
||||
display_info,
|
||||
)
|
||||
|
||||
app = typer.Typer(
|
||||
name="shell-speak",
|
||||
add_completion=False,
|
||||
help="Convert natural language to shell commands",
|
||||
)
|
||||
|
||||
|
||||
def version_callback(value: bool) -> None:
|
||||
"""Show version information."""
|
||||
if value:
|
||||
console.print(f"Shell Speak v{__version__}")
|
||||
raise typer.Exit()
|
||||
|
||||
|
||||
@app.callback()
|
||||
def main(
|
||||
version: bool = typer.Option(
|
||||
False,
|
||||
"--version",
|
||||
"-V",
|
||||
callback=version_callback,
|
||||
is_eager=True,
|
||||
help="Show version information",
|
||||
),
|
||||
) -> None:
|
||||
pass
|
||||
|
||||
|
||||
@app.command()
|
||||
def convert(
|
||||
query: str = typer.Argument(..., help="Natural language description of the command"),
|
||||
tool: str | None = typer.Option(
|
||||
None,
|
||||
"--tool",
|
||||
"-t",
|
||||
help=f"Filter by tool: {', '.join(DEFAULT_TOOLS)}",
|
||||
),
|
||||
explain: bool = typer.Option(
|
||||
False,
|
||||
"--explain",
|
||||
"-e",
|
||||
help="Show detailed explanation of the command",
|
||||
),
|
||||
dry_run: bool = typer.Option(
|
||||
False,
|
||||
"--dry-run",
|
||||
"-n",
|
||||
help="Preview the command without executing",
|
||||
),
|
||||
) -> None:
|
||||
"""Convert natural language to a shell command."""
|
||||
ensure_data_dir()
|
||||
|
||||
matcher = get_matcher()
|
||||
match = matcher.match(query, tool)
|
||||
|
||||
if match:
|
||||
display_command(match, explain=explain)
|
||||
|
||||
if dry_run:
|
||||
display_info("Dry run - command not executed")
|
||||
else:
|
||||
display_info("Use --dry-run to preview without execution")
|
||||
else:
|
||||
display_error(f"Could not find a matching command for: '{query}'")
|
||||
display_info("Try using --tool to specify which tool you're using")
|
||||
|
||||
|
||||
@app.command()
|
||||
def interactive(
|
||||
interactive_mode: bool = typer.Option(
|
||||
False,
|
||||
"--interactive",
|
||||
"-i",
|
||||
is_eager=True,
|
||||
help="Enter interactive mode",
|
||||
),
|
||||
) -> None:
|
||||
"""Enter interactive mode with history and auto-completion."""
|
||||
run_interactive_mode()
|
||||
|
||||
|
||||
@app.command()
|
||||
def history(
|
||||
limit: int = typer.Option(
|
||||
20,
|
||||
"--limit",
|
||||
"-l",
|
||||
help="Number of entries to show",
|
||||
),
|
||||
tool: str | None = typer.Option(
|
||||
None,
|
||||
"--tool",
|
||||
"-t",
|
||||
help=f"Filter by tool: {', '.join(DEFAULT_TOOLS)}",
|
||||
),
|
||||
search: str | None = typer.Option(
|
||||
None,
|
||||
"--search",
|
||||
"-s",
|
||||
help="Search history for query",
|
||||
),
|
||||
) -> None:
|
||||
"""View command history."""
|
||||
ensure_data_dir()
|
||||
history_manager = get_history_manager()
|
||||
history_manager.load()
|
||||
|
||||
if search:
|
||||
entries = history_manager.search(search, tool)
|
||||
else:
|
||||
entries = history_manager.get_recent(limit)
|
||||
|
||||
if entries:
|
||||
display_history(entries, limit)
|
||||
else:
|
||||
display_info("No history entries found")
|
||||
|
||||
|
||||
@app.command()
|
||||
def learn(
|
||||
query: str = typer.Argument(..., help="The natural language query"),
|
||||
command: str = typer.Argument(..., help="The shell command to associate"),
|
||||
tool: str = typer.Option(
|
||||
"custom",
|
||||
"--tool",
|
||||
"-t",
|
||||
help=f"Tool category: {', '.join(DEFAULT_TOOLS)}",
|
||||
),
|
||||
) -> None:
|
||||
"""Learn a new command pattern from your correction."""
|
||||
ensure_data_dir()
|
||||
loader = get_loader()
|
||||
loader.load_library()
|
||||
loader.add_correction(query, command, tool)
|
||||
display_info(f"Learned: '{query}' -> '{command}'")
|
||||
|
||||
|
||||
@app.command()
|
||||
def forget(
|
||||
query: str = typer.Argument(..., help="The query to forget"),
|
||||
tool: str = typer.Option(
|
||||
"custom",
|
||||
"--tool",
|
||||
"-t",
|
||||
help="Tool category",
|
||||
),
|
||||
) -> None:
|
||||
"""Forget a learned pattern."""
|
||||
ensure_data_dir()
|
||||
loader = get_loader()
|
||||
loader.load_library()
|
||||
|
||||
if loader.remove_correction(query, tool):
|
||||
display_info(f"Forgot pattern for: '{query}'")
|
||||
else:
|
||||
display_error(f"Pattern not found: '{query}'")
|
||||
|
||||
|
||||
@app.command()
|
||||
def reload() -> None:
|
||||
"""Reload command libraries and corrections."""
|
||||
ensure_data_dir()
|
||||
loader = get_loader()
|
||||
loader.reload()
|
||||
display_info("Command libraries reloaded")
|
||||
|
||||
|
||||
@app.command()
|
||||
def tools() -> None:
|
||||
"""List available tools."""
|
||||
console.print(Panel(
|
||||
Text("Available Tools", justify="center", style="bold cyan"),
|
||||
expand=False,
|
||||
))
|
||||
for tool in DEFAULT_TOOLS:
|
||||
console.print(f" [tool]{tool}[/]")
|
||||
|
||||
|
||||
def main_entry() -> None:
|
||||
"""Entry point for the CLI."""
|
||||
try:
|
||||
app()
|
||||
except KeyboardInterrupt:
|
||||
console.print("\n[info]Interrupted.[/]")
|
||||
sys.exit(130)
|
||||
except Exception as e:
|
||||
display_error(f"An error occurred: {e}")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main_entry()
|
||||
122
shell_speak/matcher.py
Normal file
122
shell_speak/matcher.py
Normal file
@@ -0,0 +1,122 @@
|
||||
"""Pattern matching engine for shell commands."""
|
||||
|
||||
import re
|
||||
|
||||
from shell_speak.library import get_loader
|
||||
from shell_speak.models import CommandMatch, CommandPattern
|
||||
from shell_speak.nlp import calculate_similarity, extract_keywords, normalize_text, tokenize
|
||||
|
||||
|
||||
class PatternMatcher:
|
||||
"""Matches natural language queries to command patterns."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._loader = get_loader()
|
||||
|
||||
def match(self, query: str, tool: str | None = None) -> CommandMatch | None:
|
||||
"""Match a query to the best command pattern."""
|
||||
normalized_query = normalize_text(query)
|
||||
self._loader.load_library(tool)
|
||||
|
||||
corrections = self._loader.get_corrections()
|
||||
correction_key = f"{tool}:{normalized_query}" if tool else normalized_query
|
||||
|
||||
if correction_key in corrections:
|
||||
return CommandMatch(
|
||||
pattern=CommandPattern(
|
||||
name="user_correction",
|
||||
tool=tool or "custom",
|
||||
description="User-provided correction",
|
||||
patterns=[],
|
||||
template=corrections[correction_key],
|
||||
explanation="Custom command from user correction",
|
||||
),
|
||||
confidence=1.0,
|
||||
matched_query=query,
|
||||
command=corrections[correction_key],
|
||||
explanation="This command was learned from your previous correction.",
|
||||
)
|
||||
|
||||
patterns = self._loader.get_patterns()
|
||||
if tool:
|
||||
patterns = [p for p in patterns if p.tool == tool]
|
||||
|
||||
best_match = None
|
||||
best_score = 0.0
|
||||
|
||||
for pattern in patterns:
|
||||
score = self._calculate_match_score(normalized_query, pattern)
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
command = self._substitute_template(normalized_query, pattern)
|
||||
if command:
|
||||
best_match = CommandMatch(
|
||||
pattern=pattern,
|
||||
confidence=score,
|
||||
matched_query=query,
|
||||
command=command,
|
||||
explanation=pattern.explanation or self._generate_explanation(pattern, command),
|
||||
)
|
||||
|
||||
return best_match
|
||||
|
||||
def _calculate_match_score(self, query: str, pattern: CommandPattern) -> float:
|
||||
"""Calculate how well a query matches a pattern."""
|
||||
query_keywords = extract_keywords(query)
|
||||
pattern_keywords = set()
|
||||
|
||||
for ptn in pattern.patterns:
|
||||
pattern_keywords.update(extract_keywords(ptn))
|
||||
|
||||
if not pattern_keywords:
|
||||
return 0.0
|
||||
|
||||
keyword_overlap = len(query_keywords & pattern_keywords)
|
||||
keyword_score = keyword_overlap / len(pattern_keywords) if pattern_keywords else 0.0
|
||||
|
||||
best_similarity = 0.0
|
||||
for ptn in pattern.patterns:
|
||||
sim = calculate_similarity(query, ptn)
|
||||
if sim > best_similarity:
|
||||
best_similarity = sim
|
||||
|
||||
combined_score = (keyword_score * 0.6) + (best_similarity * 0.4)
|
||||
return min(combined_score, 1.0)
|
||||
|
||||
def _substitute_template(self, query: str, pattern: CommandPattern) -> str | None:
|
||||
"""Substitute variables in the template based on query."""
|
||||
template = pattern.template
|
||||
|
||||
query_tokens = set(tokenize(query))
|
||||
pattern_tokens = set()
|
||||
for ptn in pattern.patterns:
|
||||
pattern_tokens.update(tokenize(ptn))
|
||||
|
||||
diff_tokens = query_tokens - pattern_tokens
|
||||
|
||||
variables = re.findall(r'\{(\w+)\}', template)
|
||||
var_values: dict[str, str] = {}
|
||||
|
||||
for var in variables:
|
||||
lower_var = var.lower()
|
||||
matching_tokens = [t for t in diff_tokens if lower_var in t.lower() or t.lower() in lower_var]
|
||||
if matching_tokens:
|
||||
var_values[var] = matching_tokens[0]
|
||||
|
||||
result = template
|
||||
for var, value in var_values.items():
|
||||
result = result.replace(f'{{{var}}}', value)
|
||||
|
||||
if re.search(r'\{\w+\}', result):
|
||||
return None
|
||||
|
||||
return result
|
||||
|
||||
def _generate_explanation(self, pattern: CommandPattern, command: str) -> str:
|
||||
"""Generate an explanation for the command."""
|
||||
return f"{pattern.description}"
|
||||
|
||||
|
||||
def get_matcher() -> PatternMatcher:
|
||||
"""Get the global pattern matcher."""
|
||||
return PatternMatcher()
|
||||
46
shell_speak/models.py
Normal file
46
shell_speak/models.py
Normal file
@@ -0,0 +1,46 @@
|
||||
"""Data models for shell-speak."""
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
|
||||
|
||||
@dataclass
|
||||
class CommandPattern:
|
||||
"""A pattern for matching natural language to shell commands."""
|
||||
name: str
|
||||
tool: str
|
||||
description: str
|
||||
patterns: list[str]
|
||||
template: str
|
||||
explanation: str = ""
|
||||
examples: list[str] = field(default_factory=list)
|
||||
|
||||
|
||||
@dataclass
|
||||
class CommandMatch:
|
||||
"""A match between natural language and a shell command."""
|
||||
pattern: CommandPattern
|
||||
confidence: float
|
||||
matched_query: str
|
||||
command: str
|
||||
explanation: str
|
||||
|
||||
|
||||
@dataclass
|
||||
class HistoryEntry:
|
||||
"""An entry in the command history."""
|
||||
query: str
|
||||
command: str
|
||||
tool: str
|
||||
timestamp: datetime
|
||||
explanation: str = ""
|
||||
|
||||
|
||||
@dataclass
|
||||
class Correction:
|
||||
"""A user correction for a query."""
|
||||
original_query: str
|
||||
corrected_command: str
|
||||
tool: str
|
||||
timestamp: datetime
|
||||
explanation: str = ""
|
||||
49
shell_speak/nlp.py
Normal file
49
shell_speak/nlp.py
Normal file
@@ -0,0 +1,49 @@
|
||||
"""NLP preprocessing and tokenization module."""
|
||||
|
||||
import re
|
||||
|
||||
|
||||
def normalize_text(text: str) -> str:
|
||||
"""Normalize text for matching."""
|
||||
text = text.lower().strip()
|
||||
text = re.sub(r'\s+', ' ', text)
|
||||
return text
|
||||
|
||||
|
||||
def tokenize(text: str) -> list[str]:
|
||||
"""Tokenize text into words."""
|
||||
text = normalize_text(text)
|
||||
tokens = re.findall(r'\b\w+\b', text)
|
||||
return tokens
|
||||
|
||||
|
||||
def extract_keywords(text: str) -> set[str]:
|
||||
"""Extract important keywords from text."""
|
||||
stopwords = {
|
||||
'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
|
||||
'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
|
||||
'should', 'may', 'might', 'must', 'shall', 'can', 'to', 'of', 'in',
|
||||
'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through',
|
||||
'during', 'before', 'after', 'above', 'below', 'between', 'under',
|
||||
'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where',
|
||||
'why', 'how', 'all', 'each', 'few', 'more', 'most', 'other', 'some',
|
||||
'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than',
|
||||
'too', 'very', 'just', 'and', 'but', 'if', 'or', 'because', 'until',
|
||||
'while', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she',
|
||||
'it', 'we', 'they', 'what', 'which', 'who', 'whom', 'its', 'his',
|
||||
'her', 'their', 'our', 'my', 'your', 'me', 'him', 'us', 'them',
|
||||
}
|
||||
tokens = tokenize(text)
|
||||
keywords = {t for t in tokens if t not in stopwords and len(t) > 1}
|
||||
return keywords
|
||||
|
||||
|
||||
def calculate_similarity(query1: str, query2: str) -> float:
|
||||
"""Calculate similarity between two queries using Jaccard similarity."""
|
||||
set1 = set(tokenize(query1))
|
||||
set2 = set(tokenize(query2))
|
||||
if not set1 or not set2:
|
||||
return 0.0
|
||||
intersection = len(set1 & set2)
|
||||
union = len(set1 | set2)
|
||||
return intersection / union if union > 0 else 0.0
|
||||
119
shell_speak/output.py
Normal file
119
shell_speak/output.py
Normal file
@@ -0,0 +1,119 @@
|
||||
"""Output formatting with Rich."""
|
||||
|
||||
from rich.console import Console
|
||||
from rich.panel import Panel
|
||||
from rich.syntax import Syntax
|
||||
from rich.text import Text
|
||||
from rich.theme import Theme
|
||||
|
||||
from shell_speak.models import CommandMatch, HistoryEntry
|
||||
from shell_speak.nlp import tokenize
|
||||
|
||||
custom_theme = Theme({
|
||||
"command": "bold cyan",
|
||||
"keyword": "bold green",
|
||||
"tool": "bold magenta",
|
||||
"explanation": "italic",
|
||||
"error": "bold red",
|
||||
"warning": "yellow",
|
||||
"success": "bold green",
|
||||
"info": "blue",
|
||||
})
|
||||
|
||||
|
||||
console = Console(theme=custom_theme)
|
||||
|
||||
|
||||
def display_command(match: CommandMatch, explain: bool = False) -> None:
|
||||
"""Display a command match with rich formatting."""
|
||||
syntax = Syntax(match.command, "bash", theme="monokai", line_numbers=False)
|
||||
|
||||
title = f"[tool]{match.pattern.tool}[/tool] command"
|
||||
panel = Panel(
|
||||
syntax,
|
||||
title=title,
|
||||
expand=False,
|
||||
border_style="cyan",
|
||||
)
|
||||
console.print(panel)
|
||||
|
||||
if explain or match.confidence < 0.8:
|
||||
confidence_pct = int(match.confidence * 100)
|
||||
confidence_color = "success" if match.confidence >= 0.8 else "warning" if match.confidence >= 0.5 else "error"
|
||||
console.print(f"Confidence: [{confidence_color}]{confidence_pct}%[/]")
|
||||
|
||||
if match.explanation:
|
||||
console.print(f"\n[explanation]{match.explanation}[/]")
|
||||
|
||||
if explain:
|
||||
_show_detailed_explanation(match)
|
||||
|
||||
|
||||
def _show_detailed_explanation(match: CommandMatch) -> None:
|
||||
"""Show detailed breakdown of a command."""
|
||||
console.print("\n[info]Command breakdown:[/]")
|
||||
tokens = tokenize(match.command)
|
||||
|
||||
for token in tokens:
|
||||
if token in ("docker", "kubectl", "git", "ls", "cd", "cat", "grep", "find", "rm", "cp", "mv"):
|
||||
console.print(f" [keyword]{token}[/]", end=" ")
|
||||
else:
|
||||
console.print(f" {token}", end=" ")
|
||||
|
||||
|
||||
def display_error(message: str) -> None:
|
||||
"""Display an error message."""
|
||||
console.print(f"[error]Error:[/] {message}")
|
||||
|
||||
|
||||
def display_warning(message: str) -> None:
|
||||
"""Display a warning message."""
|
||||
console.print(f"[warning]Warning:[/] {message}")
|
||||
|
||||
|
||||
def display_info(message: str) -> None:
|
||||
"""Display an info message."""
|
||||
console.print(f"[info]{message}[/]")
|
||||
|
||||
|
||||
def display_history(entries: list[HistoryEntry], limit: int = 20) -> None:
|
||||
"""Display command history."""
|
||||
console.print(f"\n[info]Command History (last {limit}):[/]\n")
|
||||
|
||||
for i, entry in enumerate(entries[-limit:], 1):
|
||||
timestamp = entry.timestamp.strftime("%Y-%m-%d %H:%M")
|
||||
console.print(f"{i}. [tool]{entry.tool}[/tool] | {timestamp}")
|
||||
console.print(f" Query: {entry.query}")
|
||||
console.print(f" [command]{entry.command}[/]")
|
||||
console.print()
|
||||
|
||||
|
||||
def display_suggestions(suggestions: list[str]) -> None:
|
||||
"""Display command suggestions."""
|
||||
if not suggestions:
|
||||
return
|
||||
|
||||
console.print("\n[info]Did you mean?[/]")
|
||||
for i, suggestion in enumerate(suggestions[:5], 1):
|
||||
console.print(f" {i}. {suggestion}")
|
||||
|
||||
|
||||
def display_learn_success(query: str, command: str) -> None:
|
||||
"""Display confirmation of learning."""
|
||||
console.print("[success]Learned new command:[/]")
|
||||
console.print(f" Query: {query}")
|
||||
console.print(f" [command]{command}[/]")
|
||||
|
||||
|
||||
def display_forget_success(query: str) -> None:
|
||||
"""Display confirmation of forgetting a pattern."""
|
||||
console.print(f"[success]Forgot pattern for:[/] {query}")
|
||||
|
||||
|
||||
def display_help_header() -> None:
|
||||
"""Display the help header."""
|
||||
console.print(Panel(
|
||||
Text("Shell Speak - Natural Language to Shell Commands", justify="center", style="bold cyan"),
|
||||
subtitle="Type a description of what you want to do",
|
||||
expand=False,
|
||||
))
|
||||
1
tests/__init__.py
Normal file
1
tests/__init__.py
Normal file
@@ -0,0 +1 @@
|
||||
"""Tests package for env-pro."""
|
||||
78
tests/conftest.py
Normal file
78
tests/conftest.py
Normal file
@@ -0,0 +1,78 @@
|
||||
"""Pytest configuration for shell-speak tests."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
os.environ["SHELL_SPEAK_DATA_DIR"] = tempfile.mkdtemp()
|
||||
os.environ["SHELL_SPEAK_HISTORY_FILE"] = os.path.join(tempfile.mkdtemp(), "history.json")
|
||||
os.environ["SHELL_SPEAK_CORRECTIONS_FILE"] = os.path.join(tempfile.mkdtemp(), "corrections.json")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_docker_yaml():
|
||||
"""Sample docker command library for testing."""
|
||||
return """
|
||||
version: "1.0"
|
||||
description: Docker test patterns
|
||||
|
||||
patterns:
|
||||
- name: list_containers
|
||||
description: List running containers
|
||||
patterns:
|
||||
- list running containers
|
||||
- show running containers
|
||||
template: docker ps
|
||||
explanation: Lists all running containers.
|
||||
|
||||
- name: run_container
|
||||
description: Run a new container
|
||||
patterns:
|
||||
- run a container
|
||||
- start a new container
|
||||
template: docker run -d --name {name} {image}
|
||||
explanation: Starts a new container.
|
||||
"""
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_git_yaml():
|
||||
"""Sample git command library for testing."""
|
||||
return """
|
||||
version: "1.0"
|
||||
description: Git test patterns
|
||||
|
||||
patterns:
|
||||
- name: git_status
|
||||
description: Show working tree status
|
||||
patterns:
|
||||
- git status
|
||||
- check status
|
||||
template: git status
|
||||
explanation: Shows the current status.
|
||||
|
||||
- name: git_commit
|
||||
description: Commit changes
|
||||
patterns:
|
||||
- commit changes
|
||||
- make commit
|
||||
template: git commit -m "{message}"
|
||||
explanation: Records changes with a message.
|
||||
"""
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_corrections_json():
|
||||
"""Sample corrections JSON for testing."""
|
||||
return {
|
||||
"version": "1.0",
|
||||
"corrections": {
|
||||
"custom:my custom query": "echo custom command",
|
||||
"docker:show running containers": "docker ps -a",
|
||||
}
|
||||
}
|
||||
0
tests/fixtures/__init__.py
vendored
Normal file
0
tests/fixtures/__init__.py
vendored
Normal file
85
tests/fixtures/sample_code.py
vendored
Normal file
85
tests/fixtures/sample_code.py
vendored
Normal file
@@ -0,0 +1,85 @@
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_python_code() -> str:
|
||||
return '''
|
||||
"""Sample Python module for testing."""
|
||||
|
||||
def function_with_docstring():
|
||||
"""This function has a docstring."""
|
||||
pass
|
||||
|
||||
def function_without_docstring():
|
||||
pass
|
||||
|
||||
class SampleClass:
|
||||
"""A sample class for testing."""
|
||||
|
||||
def __init__(self):
|
||||
self.value = 42
|
||||
|
||||
def get_value(self):
|
||||
"""Get the stored value."""
|
||||
return self.value
|
||||
|
||||
async def async_function(x: int) -> str:
|
||||
"""An async function with type hints."""
|
||||
return str(x)
|
||||
|
||||
@decorator
|
||||
def decorated_function():
|
||||
pass
|
||||
'''
|
||||
|
||||
@pytest.fixture
|
||||
def sample_javascript_code() -> str:
|
||||
return '''
|
||||
// Sample JavaScript for testing
|
||||
function regularFunction(param1, param2) {
|
||||
return param1 + param2;
|
||||
}
|
||||
|
||||
const arrowFunction = (x) => x * 2;
|
||||
|
||||
class SampleClass {
|
||||
constructor(name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
getName() {
|
||||
return this.name;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { regularFunction, SampleClass };
|
||||
'''
|
||||
|
||||
@pytest.fixture
|
||||
def sample_go_code() -> str:
|
||||
return '''package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
fmt.Println("Hello, World!")
|
||||
}
|
||||
|
||||
func add(a, b int) int {
|
||||
return a + b
|
||||
}
|
||||
'''
|
||||
|
||||
@pytest.fixture
|
||||
def temp_project_dir(tmp_path) -> Path:
|
||||
(tmp_path / "src").mkdir()
|
||||
(tmp_path / "tests").mkdir()
|
||||
(tmp_path / "main.py").write_text("def main(): pass")
|
||||
(tmp_path / "src" / "module.py").write_text("def helper(): pass")
|
||||
(tmp_path / "tests" / "test_main.py").write_text("def test_main(): pass")
|
||||
(tmp_path / ".gitignore").write_text("*.pyc")
|
||||
(tmp_path / "__pycache__").mkdir()
|
||||
(tmp_path / "__pycache__" / "cache.pyc").write_text("cached")
|
||||
return tmp_path
|
||||
1
tests/integration/__init__.py
Normal file
1
tests/integration/__init__.py
Normal file
@@ -0,0 +1 @@
|
||||
"""Integration tests package for Doc2Man."""
|
||||
141
tests/integration/test_all_formats.py
Normal file
141
tests/integration/test_all_formats.py
Normal file
@@ -0,0 +1,141 @@
|
||||
"""Integration tests for all output formats."""
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
from doc2man.parsers.python import parse_python_file
|
||||
from doc2man.generators.man import generate_man_page
|
||||
from doc2man.generators.markdown import generate_markdown
|
||||
from doc2man.generators.html import generate_html
|
||||
|
||||
|
||||
class TestAllFormatsIntegration:
|
||||
"""Integration tests for all output formats."""
|
||||
|
||||
def test_man_format(self):
|
||||
"""Test man page format output."""
|
||||
source = '''
|
||||
def command(input_file, output_file=None):
|
||||
"""Process a file and output the result.
|
||||
|
||||
Args:
|
||||
input_file: Path to input file.
|
||||
output_file: Optional path to output file.
|
||||
|
||||
Returns:
|
||||
Processed data.
|
||||
"""
|
||||
return "processed"
|
||||
'''
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(source.encode())
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as out:
|
||||
result = generate_man_page([{"file": f.name, "data": parsed}], Path(out.name))
|
||||
|
||||
assert ".TH" in result
|
||||
assert "NAME" in result
|
||||
assert "DESCRIPTION" in result
|
||||
|
||||
Path(out.name).unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_markdown_format(self):
|
||||
"""Test markdown format output."""
|
||||
source = '''
|
||||
def api(endpoint, method="GET"):
|
||||
"""Make an API request.
|
||||
|
||||
Args:
|
||||
endpoint: The API endpoint URL.
|
||||
method: HTTP method to use.
|
||||
|
||||
Returns:
|
||||
Response JSON data.
|
||||
"""
|
||||
return {"status": "ok"}
|
||||
'''
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(source.encode())
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as out:
|
||||
result = generate_markdown([{"file": f.name, "data": parsed}], Path(out.name))
|
||||
|
||||
assert "#" in result
|
||||
assert "## Functions" in result or "#" in result
|
||||
|
||||
Path(out.name).unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_html_format(self):
|
||||
"""Test HTML format output."""
|
||||
source = '''
|
||||
class DataProcessor:
|
||||
"""Process data efficiently."""
|
||||
|
||||
def process(self, data):
|
||||
"""Process the given data.
|
||||
|
||||
Args:
|
||||
data: Input data to process.
|
||||
|
||||
Returns:
|
||||
Processed result.
|
||||
"""
|
||||
return data.upper()
|
||||
'''
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(source.encode())
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as out:
|
||||
result = generate_html([{"file": f.name, "data": parsed}], Path(out.name))
|
||||
|
||||
assert "<!DOCTYPE html>" in result
|
||||
assert "<html" in result
|
||||
assert "<head>" in result
|
||||
assert "<body>" in result
|
||||
assert "<title>" in result
|
||||
assert "DataProcessor" in result
|
||||
|
||||
Path(out.name).unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_all_formats_same_data(self):
|
||||
"""Test that all formats produce consistent output from same data."""
|
||||
source = '''
|
||||
def consistent(name):
|
||||
"""A function with consistent docs.
|
||||
|
||||
Args:
|
||||
name: A name parameter.
|
||||
|
||||
Returns:
|
||||
A greeting.
|
||||
"""
|
||||
return f"Hello {name}"
|
||||
'''
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(source.encode())
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
parsed_data = [{"file": f.name, "data": parsed}]
|
||||
|
||||
man_result = generate_man_page(parsed_data, None)
|
||||
md_result = generate_markdown(parsed_data, None)
|
||||
html_result = generate_html(parsed_data, None)
|
||||
|
||||
assert "consistent" in man_result.lower()
|
||||
assert "consistent" in md_result.lower()
|
||||
assert "consistent" in html_result.lower()
|
||||
|
||||
Path(f.name).unlink()
|
||||
328
tests/integration/test_full_analysis.py
Normal file
328
tests/integration/test_full_analysis.py
Normal file
@@ -0,0 +1,328 @@
|
||||
"""Integration tests for full analysis workflow."""
|
||||
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from codesnap.core.analyzer import CodeAnalyzer
|
||||
from codesnap.core.language_detector import detect_language
|
||||
from codesnap.output.json_exporter import export_json
|
||||
from codesnap.output.llm_exporter import export_llm_optimized
|
||||
from codesnap.output.markdown_exporter import export_markdown
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_python_project(tmp_path):
|
||||
"""Create a sample Python project for testing."""
|
||||
main_py = tmp_path / "main.py"
|
||||
main_py.write_text('''
|
||||
"""Main module for the application."""
|
||||
|
||||
import os
|
||||
from utils import helper
|
||||
|
||||
|
||||
def main():
|
||||
"""Main entry point."""
|
||||
print("Hello, World!")
|
||||
helper.process()
|
||||
|
||||
|
||||
class Application:
|
||||
"""Main application class."""
|
||||
|
||||
def __init__(self, config):
|
||||
self.config = config
|
||||
|
||||
def run(self):
|
||||
"""Run the application."""
|
||||
if self.config.debug:
|
||||
print("Debug mode enabled")
|
||||
return True
|
||||
|
||||
|
||||
class Database:
|
||||
"""Database connection class."""
|
||||
|
||||
def __init__(self, host, port):
|
||||
self.host = host
|
||||
self.port = port
|
||||
|
||||
def connect(self):
|
||||
"""Establish database connection."""
|
||||
return "Connected"
|
||||
|
||||
def query(self, sql):
|
||||
"""Execute a query."""
|
||||
if not sql:
|
||||
raise ValueError("SQL query cannot be empty")
|
||||
return ["result1", "result2"]
|
||||
''')
|
||||
|
||||
utils_py = tmp_path / "utils.py"
|
||||
utils_py.write_text('''
|
||||
"""Utility functions module."""
|
||||
|
||||
import sys
|
||||
from typing import List
|
||||
|
||||
|
||||
def process():
|
||||
"""Process data."""
|
||||
return "processed"
|
||||
|
||||
|
||||
def helper(x: int, y: int) -> int:
|
||||
"""Helper function for calculations."""
|
||||
if x > 0:
|
||||
return x + y
|
||||
elif x < 0:
|
||||
return x - y
|
||||
else:
|
||||
return y
|
||||
|
||||
|
||||
class Calculator:
|
||||
"""Calculator class."""
|
||||
|
||||
def add(self, a, b):
|
||||
return a + b
|
||||
|
||||
def multiply(self, a, b):
|
||||
return a * b
|
||||
''')
|
||||
|
||||
return tmp_path
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_multilang_project(tmp_path):
|
||||
"""Create a multi-language project for testing."""
|
||||
python_file = tmp_path / "processor.py"
|
||||
python_file.write_text('''
|
||||
from js_utils import process_js
|
||||
import json
|
||||
|
||||
def handle_data(data):
|
||||
return json.dumps(process_js(data))
|
||||
''')
|
||||
|
||||
js_file = tmp_path / "js_utils.js"
|
||||
js_file.write_text('''
|
||||
function process_js(data) {
|
||||
if (data && data.length > 0) {
|
||||
return data.map(x => x * 2);
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
module.exports = { process_js };
|
||||
''')
|
||||
|
||||
go_file = tmp_path / "main.go"
|
||||
go_file.write_text('''
|
||||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
fmt.Println("Hello from Go")
|
||||
}
|
||||
|
||||
func Process() string {
|
||||
return "processed"
|
||||
}
|
||||
''')
|
||||
|
||||
return tmp_path
|
||||
|
||||
|
||||
def check_parser_available(language="python"):
|
||||
"""Check if tree-sitter parser is available for a language."""
|
||||
try:
|
||||
from codesnap.core.parser import TreeSitterParser
|
||||
_ = TreeSitterParser()
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
class TestFullAnalysis:
|
||||
"""Integration tests for full analysis workflow."""
|
||||
|
||||
def test_analyze_python_project(self, sample_python_project):
|
||||
"""Test analyzing a Python project."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=True)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
assert result.summary["total_files"] == 2
|
||||
if result.error_count == 0:
|
||||
assert result.summary["total_functions"] >= 4
|
||||
assert result.summary["total_classes"] >= 2
|
||||
|
||||
def test_analyze_multilang_project(self, sample_multilang_project):
|
||||
"""Test analyzing a multi-language project."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
|
||||
result = analyzer.analyze(sample_multilang_project)
|
||||
|
||||
assert result.summary["total_files"] == 3
|
||||
languages = result.summary.get("languages", {})
|
||||
assert "python" in languages
|
||||
assert "javascript" in languages
|
||||
assert "go" in languages
|
||||
|
||||
def test_json_export(self, sample_python_project):
|
||||
"""Test JSON export functionality."""
|
||||
analyzer = CodeAnalyzer(max_files=100)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
json_output = export_json(result, sample_python_project)
|
||||
data = json.loads(json_output)
|
||||
|
||||
assert "metadata" in data
|
||||
assert "summary" in data
|
||||
assert "files" in data
|
||||
assert len(data["files"]) == 2
|
||||
|
||||
def test_markdown_export(self, sample_python_project):
|
||||
"""Test Markdown export functionality."""
|
||||
analyzer = CodeAnalyzer(max_files=100)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
md_output = export_markdown(result, sample_python_project)
|
||||
|
||||
assert "# CodeSnap Analysis Report" in md_output
|
||||
assert "## Summary" in md_output
|
||||
assert "## File Structure" in md_output
|
||||
assert "main.py" in md_output
|
||||
|
||||
def test_llm_export(self, sample_python_project):
|
||||
"""Test LLM-optimized export functionality."""
|
||||
analyzer = CodeAnalyzer(max_files=100)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
llm_output = export_llm_optimized(result, sample_python_project, max_tokens=1000)
|
||||
|
||||
assert "## CODEBASE ANALYSIS SUMMARY" in llm_output
|
||||
assert "### STRUCTURE" in llm_output
|
||||
|
||||
def test_dependency_detection(self, sample_python_project):
|
||||
"""Test dependency detection."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
if result.error_count == 0:
|
||||
assert len(result.dependencies) >= 0
|
||||
|
||||
dep_sources = [d["source"] for d in result.dependencies]
|
||||
assert any("main.py" in src for src in dep_sources)
|
||||
|
||||
def test_complexity_analysis(self, sample_python_project):
|
||||
"""Test complexity analysis."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=True)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
files_with_complexity = [f for f in result.files if f.complexity]
|
||||
|
||||
if result.error_count == 0:
|
||||
assert len(files_with_complexity) > 0
|
||||
|
||||
for fa in files_with_complexity:
|
||||
assert fa.complexity.cyclomatic_complexity >= 1
|
||||
assert fa.complexity.nesting_depth >= 0
|
||||
|
||||
def test_ignore_patterns(self, sample_python_project):
|
||||
"""Test ignore patterns functionality."""
|
||||
ignore_analyzer = CodeAnalyzer(
|
||||
max_files=100,
|
||||
ignore_patterns=["utils.py"],
|
||||
enable_complexity=False
|
||||
)
|
||||
result = ignore_analyzer.analyze(sample_python_project)
|
||||
|
||||
file_names = [f.path.name for f in result.files]
|
||||
assert "utils.py" not in file_names
|
||||
assert "main.py" in file_names
|
||||
|
||||
def test_max_files_limit(self, sample_python_project):
|
||||
"""Test max files limit."""
|
||||
limited_analyzer = CodeAnalyzer(max_files=1)
|
||||
result = limited_analyzer.analyze(sample_python_project)
|
||||
|
||||
assert len(result.files) <= 1
|
||||
|
||||
def test_orphaned_file_detection(self, sample_python_project):
|
||||
"""Test orphaned file detection."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
orphaned = result.metrics.get("orphaned_files", [])
|
||||
if result.error_count == 0:
|
||||
assert len(orphaned) == 0
|
||||
|
||||
def test_graph_builder(self, sample_python_project):
|
||||
"""Test graph builder functionality."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
assert analyzer.graph_builder.graph.number_of_nodes() >= 1
|
||||
if result.error_count == 0:
|
||||
assert analyzer.graph_builder.graph.number_of_edges() >= 1
|
||||
|
||||
def test_language_detection_integration(self, sample_python_project):
|
||||
"""Test language detection integration."""
|
||||
python_file = sample_python_project / "main.py"
|
||||
content = python_file.read_text()
|
||||
|
||||
lang = detect_language(python_file, content)
|
||||
assert lang == "python"
|
||||
|
||||
def test_multiple_output_formats(self, sample_python_project):
|
||||
"""Test that all output formats work together."""
|
||||
analyzer = CodeAnalyzer(max_files=100, enable_complexity=True)
|
||||
result = analyzer.analyze(sample_python_project)
|
||||
|
||||
json_output = export_json(result, sample_python_project)
|
||||
md_output = export_markdown(result, sample_python_project)
|
||||
llm_output = export_llm_optimized(result, sample_python_project)
|
||||
|
||||
assert len(json_output) > 0
|
||||
assert len(md_output) > 0
|
||||
assert len(llm_output) > 0
|
||||
|
||||
json_data = json.loads(json_output)
|
||||
assert json_data["summary"]["total_files"] == result.summary["total_files"]
|
||||
|
||||
|
||||
class TestEdgeCases:
|
||||
"""Test edge cases in analysis."""
|
||||
|
||||
def test_empty_directory(self, tmp_path):
|
||||
"""Test analyzing an empty directory."""
|
||||
analyzer = CodeAnalyzer(max_files=100)
|
||||
result = analyzer.analyze(tmp_path)
|
||||
|
||||
assert result.summary["total_files"] == 0
|
||||
assert result.error_count == 0
|
||||
|
||||
def test_single_file(self, tmp_path):
|
||||
"""Test analyzing a single file."""
|
||||
test_file = tmp_path / "single.py"
|
||||
test_file.write_text("x = 1\nprint(x)")
|
||||
|
||||
analyzer = CodeAnalyzer(max_files=100)
|
||||
result = analyzer.analyze(tmp_path)
|
||||
|
||||
assert result.summary["total_files"] >= 1
|
||||
|
||||
def test_unsupported_file_types(self, tmp_path):
|
||||
"""Test handling of unsupported file types."""
|
||||
text_file = tmp_path / "readme.txt"
|
||||
text_file.write_text("This is a readme file")
|
||||
|
||||
analyzer = CodeAnalyzer(max_files=100)
|
||||
result = analyzer.analyze(tmp_path)
|
||||
|
||||
assert len(result.files) == 0 or all(
|
||||
f.language == "unknown" for f in result.files
|
||||
)
|
||||
263
tests/integration/test_full_pipeline.py
Normal file
263
tests/integration/test_full_pipeline.py
Normal file
@@ -0,0 +1,263 @@
|
||||
"""Integration tests for the full documentation pipeline."""
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
|
||||
from doc2man.cli import main
|
||||
from doc2man.parsers.python import parse_python_file
|
||||
from doc2man.parsers.go import parse_go_file
|
||||
from doc2man.parsers.javascript import parse_javascript_file
|
||||
from doc2man.generators.man import generate_man_page
|
||||
from doc2man.generators.markdown import generate_markdown
|
||||
from doc2man.generators.html import generate_html
|
||||
|
||||
|
||||
class TestFullPipeline:
|
||||
"""Integration tests for the full documentation pipeline."""
|
||||
|
||||
def test_python_to_man_pipeline(self):
|
||||
"""Test Python file -> parse -> generate man page."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(b'''
|
||||
def greet(name, greeting="Hello"):
|
||||
"""Greet a person with a custom greeting.
|
||||
|
||||
Args:
|
||||
name: The name of the person to greet.
|
||||
greeting: The greeting word to use.
|
||||
|
||||
Returns:
|
||||
The greeting string.
|
||||
|
||||
Raises:
|
||||
ValueError: If name is empty.
|
||||
"""
|
||||
if not name:
|
||||
raise ValueError("Name cannot be empty")
|
||||
return f"{greeting}, {name}!"
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
assert parsed["language"] == "python"
|
||||
assert len(parsed["functions"]) == 1
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as out:
|
||||
output_path = Path(out.name)
|
||||
result = generate_man_page([{"file": str(f.name), "data": parsed}], output_path)
|
||||
|
||||
assert ".TH" in result
|
||||
assert "NAME" in result
|
||||
assert "greet" in result.lower()
|
||||
|
||||
output_path.unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_python_to_markdown_pipeline(self):
|
||||
"""Test Python file -> parse -> generate markdown."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(b'''
|
||||
def calculate(a, b):
|
||||
"""Calculate sum of two numbers.
|
||||
|
||||
Args:
|
||||
a: First number.
|
||||
b: Second number.
|
||||
|
||||
Returns:
|
||||
The sum of a and b.
|
||||
"""
|
||||
return a + b
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as out:
|
||||
output_path = Path(out.name)
|
||||
result = generate_markdown([{"file": str(f.name), "data": parsed}], output_path)
|
||||
|
||||
assert "#" in result
|
||||
assert "calculate" in result.lower()
|
||||
assert "Parameters" in result
|
||||
|
||||
output_path.unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_python_to_html_pipeline(self):
|
||||
"""Test Python file -> parse -> generate HTML."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(b'''
|
||||
class Calculator:
|
||||
"""A simple calculator class."""
|
||||
|
||||
def add(self, a, b):
|
||||
"""Add two numbers.
|
||||
|
||||
Args:
|
||||
a: First number.
|
||||
b: Second number.
|
||||
|
||||
Returns:
|
||||
The sum.
|
||||
"""
|
||||
return a + b
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
parsed = parse_python_file(Path(f.name))
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as out:
|
||||
output_path = Path(out.name)
|
||||
result = generate_html([{"file": str(f.name), "data": parsed}], output_path)
|
||||
|
||||
assert "<!DOCTYPE html>" in result
|
||||
assert "<title>" in result
|
||||
assert "Calculator" in result
|
||||
|
||||
output_path.unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_go_pipeline(self):
|
||||
"""Test Go file parsing and generation."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".go", delete=False) as f:
|
||||
f.write(b'''
|
||||
// Package math provides math utilities.
|
||||
//
|
||||
// This is a simple math package.
|
||||
package math
|
||||
|
||||
// Add adds two integers.
|
||||
//
|
||||
// a: First integer
|
||||
// b: Second integer
|
||||
//
|
||||
// Returns: The sum
|
||||
func Add(a, b int) int {
|
||||
return a + b
|
||||
}
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
parsed = parse_go_file(Path(f.name))
|
||||
assert parsed["language"] == "go"
|
||||
assert len(parsed["functions"]) >= 1
|
||||
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_javascript_pipeline(self):
|
||||
"""Test JavaScript file parsing and generation."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".js", delete=False) as f:
|
||||
f.write(b'''
|
||||
/**
|
||||
* Multiplies two numbers.
|
||||
*
|
||||
* @param {number} a - First number
|
||||
* @param {number} b - Second number
|
||||
* @returns {number} The product
|
||||
*/
|
||||
function multiply(a, b) {
|
||||
return a * b;
|
||||
}
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
parsed = parse_javascript_file(Path(f.name))
|
||||
assert parsed["language"] == "javascript"
|
||||
assert len(parsed["functions"]) == 1
|
||||
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_typescript_pipeline(self):
|
||||
"""Test TypeScript file parsing and generation."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".ts", delete=False) as f:
|
||||
f.write(b'''
|
||||
/**
|
||||
* Divides two numbers.
|
||||
*
|
||||
* @param numerator - The numerator
|
||||
* @param denominator - The denominator
|
||||
* @returns The quotient
|
||||
*/
|
||||
function divide(numerator: number, denominator: number): number {
|
||||
return numerator / denominator;
|
||||
}
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
parsed = parse_javascript_file(Path(f.name))
|
||||
assert parsed["language"] == "javascript"
|
||||
assert len(parsed["functions"]) >= 1
|
||||
|
||||
Path(f.name).unlink()
|
||||
|
||||
|
||||
class TestCLIIntegration:
|
||||
"""Integration tests for CLI commands."""
|
||||
|
||||
def test_cli_generate_command(self):
|
||||
"""Test the full generate CLI command."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
|
||||
f.write(b'''
|
||||
def example():
|
||||
"""An example function."""
|
||||
pass
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as out:
|
||||
runner = CliRunner()
|
||||
result = runner.invoke(main, [
|
||||
"generate",
|
||||
f.name,
|
||||
"--output", out.name,
|
||||
"--format", "man"
|
||||
])
|
||||
|
||||
assert result.exit_code == 0
|
||||
assert Path(out.name).exists()
|
||||
out_path = Path(out.name)
|
||||
assert out_path.stat().st_size > 0
|
||||
|
||||
out_path.unlink()
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_cli_multiple_files(self):
|
||||
"""Test generating from multiple files."""
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f1:
|
||||
f1.write(b'''
|
||||
def func1():
|
||||
"""First function."""
|
||||
pass
|
||||
''')
|
||||
f1.flush()
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f2:
|
||||
f2.write(b'''
|
||||
def func2():
|
||||
"""Second function."""
|
||||
pass
|
||||
''')
|
||||
f2.flush()
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as out:
|
||||
runner = CliRunner()
|
||||
result = runner.invoke(main, [
|
||||
"generate",
|
||||
f1.name, f2.name,
|
||||
"--output", out.name,
|
||||
"--format", "markdown"
|
||||
])
|
||||
|
||||
assert result.exit_code == 0
|
||||
content = Path(out.name).read_text()
|
||||
assert "func1" in content or "func2" in content
|
||||
|
||||
out_path = Path(out.name)
|
||||
out_path.unlink()
|
||||
|
||||
Path(f1.name).unlink()
|
||||
Path(f2.name).unlink()
|
||||
214
tests/test_analyzer.py
Normal file
214
tests/test_analyzer.py
Normal file
@@ -0,0 +1,214 @@
|
||||
"""Tests for the analyzer module."""
|
||||
|
||||
import pytest
|
||||
from cli_diff_auditor.analyzer import AuditResult, DiffAuditor, FileAnalyzer
|
||||
from cli_diff_auditor.diff_parser import ChangeType, DiffHunk, DiffLine, FileDiff
|
||||
from cli_diff_auditor.rules import RulesLoader, Severity
|
||||
|
||||
|
||||
class TestAuditResult:
|
||||
"""Test cases for AuditResult class."""
|
||||
|
||||
def test_add_finding_error(self):
|
||||
"""Test adding an error finding."""
|
||||
result = AuditResult()
|
||||
result.add_finding(type('Finding', (), {
|
||||
'severity': Severity.ERROR
|
||||
})())
|
||||
|
||||
assert result.errors_count == 1
|
||||
assert result.warnings_count == 0
|
||||
assert result.info_count == 0
|
||||
|
||||
def test_add_finding_warning(self):
|
||||
"""Test adding a warning finding."""
|
||||
result = AuditResult()
|
||||
result.add_finding(type('Finding', (), {
|
||||
'severity': Severity.WARNING
|
||||
})())
|
||||
|
||||
assert result.errors_count == 0
|
||||
assert result.warnings_count == 1
|
||||
assert result.info_count == 0
|
||||
|
||||
def test_add_finding_info(self):
|
||||
"""Test adding an info finding."""
|
||||
result = AuditResult()
|
||||
result.add_finding(type('Finding', (), {
|
||||
'severity': Severity.INFO
|
||||
})())
|
||||
|
||||
assert result.errors_count == 0
|
||||
assert result.warnings_count == 0
|
||||
assert result.info_count == 1
|
||||
|
||||
def test_get_summary(self):
|
||||
"""Test getting the summary."""
|
||||
result = AuditResult()
|
||||
|
||||
for _ in range(2):
|
||||
result.add_finding(type('Finding', (), {'severity': Severity.ERROR})())
|
||||
for _ in range(3):
|
||||
result.add_finding(type('Finding', (), {'severity': Severity.WARNING})())
|
||||
for _ in range(1):
|
||||
result.add_finding(type('Finding', (), {'severity': Severity.INFO})())
|
||||
|
||||
summary = result.get_summary()
|
||||
|
||||
assert summary["error"] == 2
|
||||
assert summary["warning"] == 3
|
||||
assert summary["info"] == 1
|
||||
assert summary["total"] == 6
|
||||
|
||||
def test_has_errors(self):
|
||||
"""Test checking for errors."""
|
||||
result = AuditResult()
|
||||
assert result.has_errors() is False
|
||||
|
||||
result.add_finding(type('Finding', (), {'severity': Severity.ERROR})())
|
||||
assert result.has_errors() is True
|
||||
|
||||
def test_has_findings(self):
|
||||
"""Test checking for any findings."""
|
||||
result = AuditResult()
|
||||
assert result.has_findings() is False
|
||||
|
||||
result.add_finding(type('Finding', (), {'severity': Severity.INFO})())
|
||||
assert result.has_findings() is True
|
||||
|
||||
|
||||
class TestFileAnalyzer:
|
||||
"""Test cases for FileAnalyzer class."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.rules_loader = RulesLoader()
|
||||
self.rules_loader.load_builtin_rules()
|
||||
self.analyzer = FileAnalyzer(self.rules_loader)
|
||||
|
||||
def test_analyze_file_diff_finds_debug_print(self):
|
||||
"""Test that debug prints are detected."""
|
||||
file_diff = FileDiff(file_path="test.py")
|
||||
hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=2)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="print('hello')", change_type=ChangeType.ADDED),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
findings = self.analyzer.analyze_file_diff(file_diff)
|
||||
|
||||
assert len(findings) == 1
|
||||
assert findings[0].rule_id == "debug-print"
|
||||
|
||||
def test_analyze_file_diff_finds_console_log(self):
|
||||
"""Test that console.log is detected."""
|
||||
file_diff = FileDiff(file_path="test.js")
|
||||
hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=2)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="console.log('test')", change_type=ChangeType.ADDED),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
findings = self.analyzer.analyze_file_diff(file_diff)
|
||||
|
||||
assert len(findings) == 1
|
||||
assert findings[0].rule_id == "console-log"
|
||||
|
||||
def test_analyze_file_diff_ignores_clean_code(self):
|
||||
"""Test that clean code has no findings."""
|
||||
file_diff = FileDiff(file_path="test.py")
|
||||
hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=2)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="def hello():", change_type=ChangeType.ADDED),
|
||||
DiffLine(line_number=2, content=" return 'world'", change_type=ChangeType.ADDED),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
findings = self.analyzer.analyze_file_diff(file_diff)
|
||||
|
||||
assert len(findings) == 0
|
||||
|
||||
def test_analyze_binary_file(self):
|
||||
"""Test that binary files are skipped."""
|
||||
file_diff = FileDiff(file_path="image.png", is_binary=True)
|
||||
hunk = DiffHunk(old_start=1, old_lines=1, new_start=1, new_lines=1)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="binary data", change_type=ChangeType.ADDED),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
findings = self.analyzer.analyze_file_diff(file_diff)
|
||||
|
||||
assert len(findings) == 0
|
||||
|
||||
def test_analyze_deleted_lines(self):
|
||||
"""Test that deleted lines are also analyzed."""
|
||||
file_diff = FileDiff(file_path="test.py")
|
||||
hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=1)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="print('old')", change_type=ChangeType.DELETED),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
findings = self.analyzer.analyze_file_diff(file_diff)
|
||||
|
||||
assert len(findings) == 1
|
||||
assert findings[0].rule_id == "debug-print"
|
||||
|
||||
|
||||
class TestDiffAuditor:
|
||||
"""Test cases for DiffAuditor class."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.auditor = DiffAuditor()
|
||||
|
||||
def test_get_all_rules(self):
|
||||
"""Test getting all rules."""
|
||||
rules = self.auditor.get_rules()
|
||||
|
||||
assert len(rules) > 0
|
||||
assert any(r.id == "debug-print" for r in rules)
|
||||
|
||||
def test_get_enabled_rules(self):
|
||||
"""Test getting enabled rules."""
|
||||
self.auditor.disable_rules(["debug-print", "console-log"])
|
||||
|
||||
enabled = self.auditor.get_enabled_rules()
|
||||
rule_ids = [r.id for r in enabled]
|
||||
|
||||
assert "debug-print" not in rule_ids
|
||||
assert "console-log" not in rule_ids
|
||||
|
||||
def test_disable_and_enable_rules(self):
|
||||
"""Test disabling and enabling rules."""
|
||||
self.auditor.disable_rules(["debug-print"])
|
||||
enabled = self.auditor.get_enabled_rules()
|
||||
assert "debug-print" not in [r.id for r in enabled]
|
||||
|
||||
self.auditor.enable_rules(["debug-print"])
|
||||
enabled = self.auditor.get_enabled_rules()
|
||||
assert "debug-print" in [r.id for r in enabled]
|
||||
|
||||
def test_audit_diff_output(self):
|
||||
"""Test auditing diff output directly."""
|
||||
diff_output = """diff --git a/test.py b/test.py
|
||||
index 1234567..89abcdef 100644
|
||||
--- a/test.py
|
||||
+++ b/test.py
|
||||
@@ -1,2 +1,2 @@
|
||||
-old
|
||||
+print('debug')
|
||||
"""
|
||||
result = self.auditor.audit_diff_output(diff_output)
|
||||
|
||||
assert result.files_scanned == 1
|
||||
assert result.has_findings()
|
||||
assert result.warnings_count >= 1
|
||||
|
||||
def test_audit_diff_empty(self):
|
||||
"""Test auditing empty diff."""
|
||||
result = self.auditor.audit_diff_output("")
|
||||
|
||||
assert result.files_scanned == 0
|
||||
assert not result.has_findings()
|
||||
159
tests/test_autofix.py
Normal file
159
tests/test_autofix.py
Normal file
@@ -0,0 +1,159 @@
|
||||
"""Tests for the auto-fix module."""
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from cli_diff_auditor.autofix import AutoFixer, SafeWriter
|
||||
|
||||
|
||||
class TestSafeWriter:
|
||||
"""Test cases for SafeWriter class."""
|
||||
|
||||
def test_write_with_backup(self):
|
||||
"""Test writing content with backup creation."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
test_file = os.path.join(tmpdir, "test.txt")
|
||||
with open(test_file, 'w') as f:
|
||||
f.write("original content")
|
||||
|
||||
writer = SafeWriter()
|
||||
result = writer.write_with_backup(test_file, "new content")
|
||||
|
||||
assert result.success is True
|
||||
assert result.fixes_applied == 1
|
||||
with open(test_file, 'r') as f:
|
||||
assert f.read() == "new content"
|
||||
assert result.original_path != test_file
|
||||
|
||||
def test_write_without_backup(self):
|
||||
"""Test writing content without backup."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
test_file = os.path.join(tmpdir, "test.txt")
|
||||
with open(test_file, 'w') as f:
|
||||
f.write("original content")
|
||||
|
||||
writer = SafeWriter()
|
||||
result = writer.write_with_backup(test_file, "new content", create_backup=False)
|
||||
|
||||
assert result.success is True
|
||||
assert result.original_path == test_file
|
||||
|
||||
def test_remove_trailing_whitespace(self):
|
||||
"""Test removing trailing whitespace."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("line1 \n")
|
||||
f.write("line2\t\n")
|
||||
f.write("line3\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
fixer = AutoFixer()
|
||||
result = fixer.remove_trailing_whitespace(temp_path)
|
||||
|
||||
assert result.success is True
|
||||
with open(temp_path, 'r') as f:
|
||||
content = f.read()
|
||||
assert content == "line1\nline2\nline3\n"
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_remove_trailing_whitespace_no_changes(self):
|
||||
"""Test removing trailing whitespace when none exists."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("line1\nline2\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
fixer = AutoFixer()
|
||||
result = fixer.remove_trailing_whitespace(temp_path)
|
||||
|
||||
assert result.success is True
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_fix_notimplemented_error(self):
|
||||
"""Test fixing NotImplemented to NotImplementedError."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("def foo():\n raise NotImplemented\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
fixer = AutoFixer()
|
||||
result = fixer.fix_notimplemented_error(temp_path)
|
||||
|
||||
assert result.success is True
|
||||
with open(temp_path, 'r') as f:
|
||||
content = f.read()
|
||||
assert "raise NotImplementedError" in content
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_apply_regex_fixes(self):
|
||||
"""Test applying regex-based fixes."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("old_value = 1\nold_value = 2\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
fixer = AutoFixer()
|
||||
result = fixer.apply_regex_fixes(
|
||||
temp_path,
|
||||
r"old_value",
|
||||
"new_value"
|
||||
)
|
||||
|
||||
assert result.success is True
|
||||
with open(temp_path, 'r') as f:
|
||||
content = f.read()
|
||||
assert "new_value = 1" in content
|
||||
assert "new_value = 2" in content
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_apply_regex_fixes_no_matches(self):
|
||||
"""Test regex fix with no matches."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("other_value = 1\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
fixer = AutoFixer()
|
||||
result = fixer.apply_regex_fixes(
|
||||
temp_path,
|
||||
r"nonexistent",
|
||||
"replacement"
|
||||
)
|
||||
|
||||
assert result.success is True
|
||||
assert result.fixes_applied == 0
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_remove_debug_imports(self):
|
||||
"""Test removing debug imports."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("import ipdb\nimport pdb\ncode here\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
fixer = AutoFixer()
|
||||
result = fixer.remove_debug_imports(temp_path)
|
||||
|
||||
assert result.success is True
|
||||
with open(temp_path, 'r') as f:
|
||||
content = f.read()
|
||||
assert "# import ipdb" in content
|
||||
assert "# import pdb" in content
|
||||
assert "code here" in content
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_file_not_found(self):
|
||||
"""Test fixing a non-existent file."""
|
||||
fixer = AutoFixer()
|
||||
result = fixer.remove_trailing_whitespace("/nonexistent/file.txt")
|
||||
|
||||
assert result.success is False
|
||||
assert "no such file" in result.error_message.lower() or "not found" in result.error_message.lower()
|
||||
157
tests/test_cli.py
Normal file
157
tests/test_cli.py
Normal file
@@ -0,0 +1,157 @@
|
||||
"""Tests for CLI interface."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def cli_runner():
|
||||
"""Create a CLI runner for testing."""
|
||||
from typer.testing import CliRunner
|
||||
|
||||
from shell_speak.main import app
|
||||
return CliRunner(), app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def setup_test_env(tmp_path, sample_docker_yaml, sample_git_yaml):
|
||||
"""Set up test environment with sample libraries."""
|
||||
docker_file = tmp_path / "docker.yaml"
|
||||
docker_file.write_text(sample_docker_yaml)
|
||||
|
||||
git_file = tmp_path / "git.yaml"
|
||||
git_file.write_text(sample_git_yaml)
|
||||
|
||||
os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
|
||||
os.environ["SHELL_SPEAK_HISTORY_FILE"] = str(tmp_path / "history.json")
|
||||
os.environ["SHELL_SPEAK_CORRECTIONS_FILE"] = str(tmp_path / "corrections.json")
|
||||
|
||||
|
||||
class TestCLIConvert:
|
||||
"""Tests for the convert command."""
|
||||
|
||||
def test_convert_basic_query(self, cli_runner, setup_test_env):
|
||||
"""Test basic query conversion."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["convert", "list running containers"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "docker ps" in result.stdout or "docker" in result.stdout.lower()
|
||||
|
||||
def test_convert_with_tool_filter(self, cli_runner, setup_test_env):
|
||||
"""Test query with tool filter."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["convert", "--tool", "docker", "list running containers"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "docker" in result.stdout.lower()
|
||||
|
||||
def test_convert_unknown_query(self, cli_runner, setup_test_env):
|
||||
"""Test unknown query returns error."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["convert", "xyz unknown query"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "not found" in result.stdout.lower() or "could not" in result.stdout.lower()
|
||||
|
||||
|
||||
class TestCLIHistory:
|
||||
"""Tests for the history command."""
|
||||
|
||||
def test_history_empty(self, cli_runner, setup_test_env):
|
||||
"""Test history with empty entries."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["history"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_history_with_limit(self, cli_runner, setup_test_env):
|
||||
"""Test history with limit option."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["history", "--limit", "10"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
|
||||
|
||||
class TestCLILearn:
|
||||
"""Tests for the learn command."""
|
||||
|
||||
def test_learn_new_pattern(self, cli_runner, setup_test_env):
|
||||
"""Test learning a new pattern."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["learn", "test query", "echo test", "--tool", "unix"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "learned" in result.stdout.lower() or "test query" in result.stdout
|
||||
|
||||
|
||||
class TestCLIForget:
|
||||
"""Tests for the forget command."""
|
||||
|
||||
def test_forget_pattern(self, cli_runner, setup_test_env):
|
||||
"""Test forgetting a pattern."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["forget", "test query", "--tool", "unix"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
|
||||
|
||||
class TestCLIReload:
|
||||
"""Tests for the reload command."""
|
||||
|
||||
def test_reload_command(self, cli_runner, setup_test_env):
|
||||
"""Test reload command."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["reload"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "reloaded" in result.stdout.lower()
|
||||
|
||||
|
||||
class TestCLITools:
|
||||
"""Tests for the tools command."""
|
||||
|
||||
def test_tools_command(self, cli_runner):
|
||||
"""Test listing available tools."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["tools"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "docker" in result.stdout.lower()
|
||||
|
||||
|
||||
class TestCLIVersion:
|
||||
"""Tests for version option."""
|
||||
|
||||
def test_version_flag(self, cli_runner):
|
||||
"""Test --version flag."""
|
||||
runner, app = cli_runner
|
||||
result = runner.invoke(
|
||||
app,
|
||||
["--version"]
|
||||
)
|
||||
assert result.exit_code == 0
|
||||
assert "shell speak" in result.stdout.lower() or "version" in result.stdout.lower()
|
||||
329
tests/test_cli_commands.py
Normal file
329
tests/test_cli_commands.py
Normal file
@@ -0,0 +1,329 @@
|
||||
"""Tests for CLI commands."""
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import os
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def cli_runner():
|
||||
"""Create a Click CLI runner."""
|
||||
return CliRunner()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def project_runner(temp_dir, cli_runner):
|
||||
"""Create a CLI runner with a temporary project."""
|
||||
os.chdir(temp_dir)
|
||||
yield cli_runner
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestInitCommand:
|
||||
"""Tests for init command."""
|
||||
|
||||
def test_init_creates_structure(self, temp_dir, cli_runner):
|
||||
"""Test that init creates the required directory structure."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
|
||||
assert result.exit_code == 0, f"Error: {result.output}"
|
||||
assert (temp_dir / ".env-profiles").exists()
|
||||
assert (temp_dir / ".env-profiles" / ".active").exists()
|
||||
assert (temp_dir / ".env-profiles" / "default" / ".env").exists()
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_init_with_template(self, temp_dir, cli_runner):
|
||||
"""Test init with a template."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init", "--template", "fastapi"])
|
||||
|
||||
assert result.exit_code == 0
|
||||
content = (temp_dir / ".env-profiles" / "default" / ".env").read_text()
|
||||
assert "APP_NAME" in content or result.exit_code == 0
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestProfileCommands:
|
||||
"""Tests for profile commands."""
|
||||
|
||||
def test_profile_create(self, temp_dir, cli_runner):
|
||||
"""Test creating a new profile."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["profile", "create", "staging"])
|
||||
assert result.exit_code == 0, f"Error: {result.output}"
|
||||
assert (temp_dir / ".env-profiles" / "staging").exists()
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_profile_list(self, temp_dir, cli_runner):
|
||||
"""Test listing profiles."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["profile", "list"])
|
||||
assert result.exit_code == 0
|
||||
assert "default" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_profile_use(self, temp_dir, cli_runner):
|
||||
"""Test setting active profile."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["profile", "create", "prod"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["profile", "use", "prod"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
active = (temp_dir / ".env-profiles" / ".active").read_text()
|
||||
assert active == "prod"
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_profile_delete(self, temp_dir, cli_runner):
|
||||
"""Test deleting a profile."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["profile", "create", "test"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["profile", "delete", "test", "--force"])
|
||||
assert result.exit_code == 0
|
||||
assert not (temp_dir / ".env-profiles" / "test").exists()
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestVariableCommands:
|
||||
"""Tests for variable commands."""
|
||||
|
||||
def test_add_variable(self, temp_dir, cli_runner):
|
||||
"""Test adding a variable."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "DATABASE_URL", "postgresql://localhost/db"])
|
||||
assert result.exit_code == 0, f"Error: {result.output}"
|
||||
|
||||
env_file = temp_dir / ".env-profiles" / "default" / ".env"
|
||||
content = env_file.read_text()
|
||||
assert "DATABASE_URL" in content
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_set_variable(self, temp_dir, cli_runner):
|
||||
"""Test setting a variable."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "DEBUG", "true"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["set", "DEBUG", "false"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
env_file = temp_dir / ".env-profiles" / "default" / ".env"
|
||||
content = env_file.read_text()
|
||||
assert "DEBUG=" in content
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_list_variables(self, temp_dir, cli_runner):
|
||||
"""Test listing variables."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "TEST_VAR", "test-value"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["list"])
|
||||
assert result.exit_code == 0
|
||||
assert "TEST_VAR" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_get_variable(self, temp_dir, cli_runner):
|
||||
"""Test getting a variable."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "MY_VAR", "my-value"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["get", "MY_VAR"])
|
||||
assert result.exit_code == 0
|
||||
assert "my-value" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_delete_variable(self, temp_dir, cli_runner):
|
||||
"""Test deleting a variable."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "TO_DELETE", "value"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["delete", "TO_DELETE"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["get", "TO_DELETE"])
|
||||
assert result.exit_code != 0 or "not found" in result.output.lower()
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestTemplateCommands:
|
||||
"""Tests for template commands."""
|
||||
|
||||
def test_template_list(self, temp_dir, cli_runner):
|
||||
"""Test listing templates."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["template", "list"])
|
||||
assert result.exit_code == 0
|
||||
assert "fastapi" in result.output or "minimal" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_template_show(self, temp_dir, cli_runner):
|
||||
"""Test showing template details."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["template", "show", "minimal"])
|
||||
assert result.exit_code == 0
|
||||
assert "Template:" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestValidationCommands:
|
||||
"""Tests for validation commands."""
|
||||
|
||||
def test_validate_no_schema(self, temp_dir, cli_runner):
|
||||
"""Test validation when no schema exists."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["validate"])
|
||||
assert result.exit_code == 0 or "No schema" in result.output or "Validation error" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_check_no_schema(self, temp_dir, cli_runner):
|
||||
"""Test check when no schema exists."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["check"])
|
||||
assert result.exit_code == 0 or "No schema" in result.output or "Check error" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestExportCommands:
|
||||
"""Tests for export commands."""
|
||||
|
||||
def test_export_shell_format(self, temp_dir, cli_runner):
|
||||
"""Test exporting variables in shell format."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "TEST_VAR", "test-value"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["export", "--format", "shell"])
|
||||
assert result.exit_code == 0
|
||||
assert "TEST_VAR=test-value" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_export_json_format(self, temp_dir, cli_runner):
|
||||
"""Test exporting variables in JSON format."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "JSON_VAR", "json-value"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["export", "--format", "json"])
|
||||
assert result.exit_code == 0
|
||||
assert "JSON_VAR" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
|
||||
class TestGitOpsCommands:
|
||||
"""Tests for GitOps commands."""
|
||||
|
||||
def test_gitignore_output(self, temp_dir, cli_runner):
|
||||
"""Test gitignore generation."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["gitignore"])
|
||||
assert result.exit_code == 0
|
||||
assert ".env-profiles" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
|
||||
def test_example_output(self, temp_dir, cli_runner):
|
||||
"""Test .env.example generation."""
|
||||
from env_pro.cli import main
|
||||
|
||||
os.chdir(temp_dir)
|
||||
try:
|
||||
result = cli_runner.invoke(main, ["init"])
|
||||
result = cli_runner.invoke(main, ["add", "EXAMPLE_VAR", "example-value"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(main, ["example"])
|
||||
assert result.exit_code == 0
|
||||
assert "EXAMPLE_VAR" in result.output
|
||||
finally:
|
||||
os.chdir("/")
|
||||
128
tests/test_command_library.py
Normal file
128
tests/test_command_library.py
Normal file
@@ -0,0 +1,128 @@
|
||||
"""Tests for command library loader."""
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
|
||||
class TestCommandLibraryLoader:
|
||||
"""Tests for CommandLibraryLoader class."""
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def setup(self, tmp_path, sample_docker_yaml, sample_git_yaml):
|
||||
self.test_dir = tmp_path
|
||||
|
||||
docker_file = self.test_dir / "docker.yaml"
|
||||
docker_file.write_text(sample_docker_yaml)
|
||||
|
||||
git_file = self.test_dir / "git.yaml"
|
||||
git_file.write_text(sample_git_yaml)
|
||||
|
||||
os.environ["SHELL_SPEAK_DATA_DIR"] = str(self.test_dir)
|
||||
|
||||
def test_load_docker_library(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library("docker")
|
||||
|
||||
patterns = loader.get_patterns()
|
||||
assert len(patterns) > 0
|
||||
assert any(p.tool == "docker" for p in patterns)
|
||||
|
||||
def test_load_git_library(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library("git")
|
||||
|
||||
patterns = loader.get_patterns()
|
||||
assert len(patterns) > 0
|
||||
assert any(p.tool == "git" for p in patterns)
|
||||
|
||||
def test_load_all_libraries(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library()
|
||||
|
||||
patterns = loader.get_patterns()
|
||||
docker_patterns = [p for p in patterns if p.tool == "docker"]
|
||||
git_patterns = [p for p in patterns if p.tool == "git"]
|
||||
assert len(docker_patterns) > 0
|
||||
assert len(git_patterns) > 0
|
||||
|
||||
def test_pattern_structure(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library("docker")
|
||||
|
||||
patterns = loader.get_patterns()
|
||||
if patterns:
|
||||
pattern = patterns[0]
|
||||
assert hasattr(pattern, "name")
|
||||
assert hasattr(pattern, "tool")
|
||||
assert hasattr(pattern, "template")
|
||||
assert hasattr(pattern, "patterns")
|
||||
|
||||
def test_corrections(self, tmp_path, sample_corrections_json):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
corrections_file = tmp_path / "corrections.json"
|
||||
corrections_file.write_text(json.dumps(sample_corrections_json))
|
||||
|
||||
os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library()
|
||||
|
||||
corrections = loader.get_corrections()
|
||||
assert "custom:my custom query" in corrections
|
||||
assert corrections["custom:my custom query"] == "echo custom command"
|
||||
|
||||
def test_add_correction(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library()
|
||||
|
||||
loader.add_correction("new query", "echo new", "unix")
|
||||
corrections = loader.get_corrections()
|
||||
assert "unix:new query" in corrections
|
||||
|
||||
def test_remove_correction(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader.load_library()
|
||||
|
||||
loader.add_correction("test query", "echo test", "unix")
|
||||
loader.remove_correction("test query", "unix")
|
||||
|
||||
corrections = loader.get_corrections()
|
||||
assert "unix:test query" not in corrections
|
||||
|
||||
def test_reload(self):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
loader = get_loader()
|
||||
loader.load_library()
|
||||
initial_count = len(loader.get_patterns())
|
||||
|
||||
loader.reload()
|
||||
reload_count = len(loader.get_patterns())
|
||||
|
||||
assert initial_count == reload_count
|
||||
250
tests/test_diff_parser.py
Normal file
250
tests/test_diff_parser.py
Normal file
@@ -0,0 +1,250 @@
|
||||
"""Tests for the diff parser module."""
|
||||
|
||||
import pytest
|
||||
from cli_diff_auditor.diff_parser import (
|
||||
ChangeType,
|
||||
DiffHunk,
|
||||
DiffLine,
|
||||
DiffParser,
|
||||
FileDiff,
|
||||
)
|
||||
|
||||
|
||||
class TestDiffParser:
|
||||
"""Test cases for DiffParser class."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.parser = DiffParser()
|
||||
|
||||
def test_parse_empty_diff(self):
|
||||
"""Test parsing an empty diff."""
|
||||
result = self.parser.parse_diff("")
|
||||
assert result == []
|
||||
|
||||
def test_parse_none_diff(self):
|
||||
"""Test parsing a None-like diff."""
|
||||
result = self.parser.parse_diff(" ")
|
||||
assert result == []
|
||||
|
||||
def test_parse_simple_diff(self):
|
||||
"""Test parsing a simple file modification diff."""
|
||||
diff_output = """diff --git a/test.py b/test.py
|
||||
index 1234567..89abcdef 100644
|
||||
--- a/test.py
|
||||
+++ b/test.py
|
||||
@@ -1,3 +1,3 @@
|
||||
line 1
|
||||
-old line
|
||||
+new line
|
||||
line 3
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 1
|
||||
assert result[0].file_path == "test.py"
|
||||
assert result[0].change_type == ChangeType.MODIFIED
|
||||
|
||||
def test_parse_added_file_diff(self):
|
||||
"""Test parsing a diff for a newly added file."""
|
||||
diff_output = """diff --git a/newfile.py b/newfile.py
|
||||
new file mode 100644
|
||||
index 0000000..1234567
|
||||
--- /dev/null
|
||||
+++ b/newfile.py
|
||||
@@ -0,0 +1,2 @@
|
||||
+line 1
|
||||
+line 2
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 1
|
||||
assert result[0].change_type == ChangeType.ADDED
|
||||
assert result[0].file_path == "newfile.py"
|
||||
|
||||
def test_parse_deleted_file_diff(self):
|
||||
"""Test parsing a diff for a deleted file."""
|
||||
diff_output = """diff --git a/oldfile.py b/oldfile.py
|
||||
deleted file mode 100644
|
||||
index 1234567..0000000
|
||||
--- a/oldfile.py
|
||||
+++ /dev/null
|
||||
@@ -1,2 +0,0 @@
|
||||
-line 1
|
||||
-line 2
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 1
|
||||
assert result[0].change_type == ChangeType.DELETED
|
||||
|
||||
def test_parse_multiple_files(self):
|
||||
"""Test parsing a diff with multiple files."""
|
||||
diff_output = """diff --git a/file1.py b/file1.py
|
||||
index 1234567..89abcdef 100644
|
||||
--- a/file1.py
|
||||
+++ b/file1.py
|
||||
@@ -1,2 +1,2 @@
|
||||
-old
|
||||
+new
|
||||
|
||||
diff --git a/file2.py b/file2.py
|
||||
index abcdefg..1234567 100644
|
||||
--- a/file2.py
|
||||
+++ b/file2.py
|
||||
@@ -1,2 +1,2 @@
|
||||
-old2
|
||||
+new2
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 2
|
||||
assert result[0].file_path == "file1.py"
|
||||
assert result[1].file_path == "file2.py"
|
||||
|
||||
def test_extract_line_content(self):
|
||||
"""Test extracting line contents from a file diff."""
|
||||
diff_output = """diff --git a/test.py b/test.py
|
||||
index 1234567..89abcdef 100644
|
||||
--- a/test.py
|
||||
+++ b/test.py
|
||||
@@ -1,5 +1,5 @@
|
||||
context line
|
||||
-old line
|
||||
+new line 1
|
||||
+new line 2
|
||||
context line 2
|
||||
-old line 2
|
||||
+new line 3
|
||||
context line 3
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 1
|
||||
file_diff = result[0]
|
||||
|
||||
lines = self.parser.extract_line_content(file_diff)
|
||||
|
||||
assert len(lines) == 5
|
||||
assert all(isinstance(line, tuple) and len(line) == 3 for line in lines)
|
||||
changed_types = [line[2] for line in lines]
|
||||
assert ChangeType.ADDED in changed_types
|
||||
assert ChangeType.DELETED in changed_types
|
||||
|
||||
def test_get_changed_lines(self):
|
||||
"""Test getting only changed lines from a hunk."""
|
||||
diff_output = """diff --git a/test.py b/test.py
|
||||
index 1234567..89abcdef 100644
|
||||
--- a/test.py
|
||||
+++ b/test.py
|
||||
@@ -1,4 +1,5 @@
|
||||
context
|
||||
-added
|
||||
+modified
|
||||
+another added
|
||||
context again
|
||||
-deleted
|
||||
final context
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 1
|
||||
file_diff = result[0]
|
||||
|
||||
assert len(file_diff.hunks) == 1
|
||||
hunk = file_diff.hunks[0]
|
||||
|
||||
changed_lines = hunk.get_changed_lines()
|
||||
|
||||
assert len(changed_lines) == 4
|
||||
for line in changed_lines:
|
||||
assert line.is_context is False
|
||||
|
||||
def test_hunk_attributes(self):
|
||||
"""Test that hunk header attributes are correctly parsed."""
|
||||
diff_output = """diff --git a/test.py b/test.py
|
||||
index 1234567..89abcdef 100644
|
||||
--- a/test.py
|
||||
+++ b/test.py
|
||||
@@ -5,10 +7,15 @@
|
||||
"""
|
||||
result = self.parser.parse_diff(diff_output)
|
||||
|
||||
assert len(result) == 1
|
||||
hunk = result[0].hunks[0]
|
||||
|
||||
assert hunk.old_start == 5
|
||||
assert hunk.old_lines == 10
|
||||
assert hunk.new_start == 7
|
||||
assert hunk.new_lines == 15
|
||||
|
||||
|
||||
class TestDiffLine:
|
||||
"""Test cases for DiffLine class."""
|
||||
|
||||
def test_diff_line_creation(self):
|
||||
"""Test creating a DiffLine instance."""
|
||||
line = DiffLine(
|
||||
line_number=10,
|
||||
content="print('hello')",
|
||||
change_type=ChangeType.ADDED
|
||||
)
|
||||
|
||||
assert line.line_number == 10
|
||||
assert line.content == "print('hello')"
|
||||
assert line.change_type == ChangeType.ADDED
|
||||
assert line.is_context is False
|
||||
|
||||
def test_diff_line_context(self):
|
||||
"""Test creating a context DiffLine."""
|
||||
line = DiffLine(
|
||||
line_number=5,
|
||||
content="def foo():",
|
||||
change_type=ChangeType.MODIFIED,
|
||||
is_context=True
|
||||
)
|
||||
|
||||
assert line.is_context is True
|
||||
|
||||
|
||||
class TestFileDiff:
|
||||
"""Test cases for FileDiff class."""
|
||||
|
||||
def test_get_added_lines(self):
|
||||
"""Test getting only added lines from a file diff."""
|
||||
file_diff = FileDiff(
|
||||
file_path="test.py",
|
||||
change_type=ChangeType.MODIFIED
|
||||
)
|
||||
|
||||
hunk = DiffHunk(old_start=1, old_lines=3, new_start=1, new_lines=4)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="old", change_type=ChangeType.DELETED),
|
||||
DiffLine(line_number=2, content="new", change_type=ChangeType.ADDED),
|
||||
DiffLine(line_number=3, content="context", change_type=ChangeType.MODIFIED, is_context=True),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
added_lines = file_diff.get_added_lines()
|
||||
|
||||
assert len(added_lines) == 1
|
||||
assert added_lines[0].change_type == ChangeType.ADDED
|
||||
|
||||
def test_get_deleted_lines(self):
|
||||
"""Test getting only deleted lines from a file diff."""
|
||||
file_diff = FileDiff(
|
||||
file_path="test.py",
|
||||
change_type=ChangeType.MODIFIED
|
||||
)
|
||||
|
||||
hunk = DiffHunk(old_start=1, old_lines=3, new_start=1, new_lines=2)
|
||||
hunk.lines = [
|
||||
DiffLine(line_number=1, content="old", change_type=ChangeType.DELETED),
|
||||
DiffLine(line_number=2, content="new", change_type=ChangeType.ADDED),
|
||||
]
|
||||
file_diff.hunks.append(hunk)
|
||||
|
||||
deleted_lines = file_diff.get_deleted_lines()
|
||||
|
||||
assert len(deleted_lines) == 1
|
||||
assert deleted_lines[0].change_type == ChangeType.DELETED
|
||||
111
tests/test_encryption.py
Normal file
111
tests/test_encryption.py
Normal file
@@ -0,0 +1,111 @@
|
||||
"""Tests for encryption module."""
|
||||
|
||||
import pytest
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
|
||||
|
||||
class TestEncryption:
|
||||
"""Test cases for encryption module."""
|
||||
|
||||
def test_derive_key(self):
|
||||
"""Test key derivation from passphrase."""
|
||||
from env_pro.core.encryption import derive_key, generate_salt
|
||||
|
||||
passphrase = "test-passphrase"
|
||||
salt = generate_salt()
|
||||
|
||||
key1 = derive_key(passphrase, salt)
|
||||
key2 = derive_key(passphrase, salt)
|
||||
|
||||
assert len(key1) == 32
|
||||
assert key1 == key2
|
||||
|
||||
def test_generate_key(self):
|
||||
"""Test random key generation."""
|
||||
from env_pro.core.encryption import generate_key, verify_key
|
||||
|
||||
key = generate_key()
|
||||
assert verify_key(key)
|
||||
assert len(key) == 32
|
||||
|
||||
def test_generate_salt(self):
|
||||
"""Test salt generation."""
|
||||
from env_pro.core.encryption import generate_salt
|
||||
|
||||
salt = generate_salt()
|
||||
assert len(salt) == 16
|
||||
|
||||
def test_generate_nonce(self):
|
||||
"""Test nonce generation."""
|
||||
from env_pro.core.encryption import generate_nonce
|
||||
|
||||
nonce = generate_nonce()
|
||||
assert len(nonce) == 12
|
||||
|
||||
def test_encrypt_decrypt_value(self, mocker):
|
||||
"""Test encryption and decryption of a value."""
|
||||
from env_pro.core.encryption import (
|
||||
encrypt_value, decrypt_value, generate_key, store_key_in_keyring
|
||||
)
|
||||
|
||||
mocker.patch('keyring.set_password', return_value=None)
|
||||
mocker.patch('keyring.get_password', return_value=None)
|
||||
|
||||
key = generate_key()
|
||||
store_key_in_keyring(key)
|
||||
|
||||
original = "my-secret-value"
|
||||
encrypted = encrypt_value(original, key)
|
||||
decrypted = decrypt_value(encrypted, key)
|
||||
|
||||
assert decrypted == original
|
||||
assert encrypted != original
|
||||
|
||||
def test_encrypt_value_different_each_time(self):
|
||||
"""Test that encryption produces different outputs."""
|
||||
from env_pro.core.encryption import encrypt_value, generate_key
|
||||
|
||||
key = generate_key()
|
||||
original = "same-value"
|
||||
|
||||
encrypted1 = encrypt_value(original, key)
|
||||
encrypted2 = encrypt_value(original, key)
|
||||
|
||||
assert encrypted1 != encrypted2
|
||||
|
||||
def test_encrypt_file_structure(self):
|
||||
"""Test file encryption produces valid structure."""
|
||||
from env_pro.core.encryption import encrypt_file, generate_key
|
||||
|
||||
key = generate_key()
|
||||
content = "DATABASE_URL=postgresql://localhost:5432/db\nDEBUG=true"
|
||||
|
||||
result = encrypt_file(content, key)
|
||||
|
||||
assert "salt" in result
|
||||
assert "nonce" in result
|
||||
assert "ciphertext" in result
|
||||
|
||||
def test_decrypt_file(self):
|
||||
"""Test file decryption."""
|
||||
from env_pro.core.encryption import encrypt_file, decrypt_file, generate_key
|
||||
|
||||
key = generate_key()
|
||||
original = "SECRET_KEY=my-secret\nAPI_KEY=12345"
|
||||
|
||||
encrypted = encrypt_file(original, key)
|
||||
decrypted = decrypt_file(encrypted, key)
|
||||
|
||||
assert decrypted == original
|
||||
|
||||
|
||||
class TestEncryptionErrors:
|
||||
"""Test cases for encryption errors."""
|
||||
|
||||
def test_invalid_encrypted_value(self):
|
||||
"""Test decryption of invalid data."""
|
||||
from env_pro.core.encryption import decrypt_value, EncryptionError
|
||||
|
||||
with pytest.raises(EncryptionError):
|
||||
decrypt_value("invalid-base64-data!!!")
|
||||
126
tests/test_explainer.py
Normal file
126
tests/test_explainer.py
Normal file
@@ -0,0 +1,126 @@
|
||||
"""Tests for the explainer module."""
|
||||
|
||||
from cli_explain_fix.parser import ErrorParser
|
||||
from cli_explain_fix.explainer import Explainer
|
||||
from cli_explain_fix.knowledge_base import KnowledgeBase
|
||||
|
||||
|
||||
class TestExplainer:
|
||||
"""Test cases for Explainer."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up explainer instance for each test."""
|
||||
self.parser = ErrorParser()
|
||||
self.kb = KnowledgeBase()
|
||||
self.explainer = Explainer(self.kb)
|
||||
|
||||
def test_explain_python_error(self, sample_python_simple_error):
|
||||
"""Test explaining a Python error."""
|
||||
parsed = self.parser.parse(sample_python_simple_error)
|
||||
explanation = self.explainer.explain(parsed)
|
||||
|
||||
assert "error_type" in explanation
|
||||
assert "language" in explanation
|
||||
assert "summary" in explanation
|
||||
assert "what_happened" in explanation
|
||||
assert "why_happened" in explanation
|
||||
assert "how_to_fix" in explanation
|
||||
|
||||
assert explanation["error_type"] == "ValueError"
|
||||
assert explanation["language"] == "python"
|
||||
|
||||
def test_explain_python_traceback(self, sample_python_traceback):
|
||||
"""Test explaining Python traceback."""
|
||||
parsed = self.parser.parse(sample_python_traceback)
|
||||
explanation = self.explainer.explain(parsed)
|
||||
|
||||
assert explanation["error_type"] == "ModuleNotFoundError"
|
||||
assert explanation["language"] == "python"
|
||||
assert "location" in explanation
|
||||
assert "/app/main.py" in explanation["location"]["file"]
|
||||
assert explanation["location"]["line"] == 10
|
||||
|
||||
def test_explain_javascript_error(self, sample_js_error):
|
||||
"""Test explaining JavaScript error."""
|
||||
parsed = self.parser.parse(sample_js_error)
|
||||
explanation = self.explainer.explain(parsed)
|
||||
|
||||
assert explanation["error_type"] == "TypeError"
|
||||
assert explanation["language"] == "javascript"
|
||||
|
||||
def test_explain_verbose_mode(self, sample_python_simple_error):
|
||||
"""Test explaining with verbose flag."""
|
||||
parsed = self.parser.parse(sample_python_simple_error)
|
||||
explanation = self.explainer.explain(parsed, verbose=True)
|
||||
|
||||
assert "raw_error" in explanation
|
||||
|
||||
def test_explain_without_verbose(self, sample_python_simple_error):
|
||||
"""Test explaining without verbose flag."""
|
||||
parsed = self.parser.parse(sample_python_simple_error)
|
||||
explanation = self.explainer.explain(parsed, verbose=False)
|
||||
|
||||
assert "raw_error" not in explanation
|
||||
|
||||
def test_explain_with_stack_trace(self, sample_python_traceback):
|
||||
"""Test explaining error with stack frames."""
|
||||
parsed = self.parser.parse(sample_python_traceback)
|
||||
explanation = self.explainer.explain(parsed)
|
||||
|
||||
assert "stack_trace" in explanation
|
||||
assert len(explanation["stack_trace"]) > 0
|
||||
|
||||
def test_explain_with_code_examples(self, sample_python_simple_error):
|
||||
"""Test that code examples are included."""
|
||||
parsed = self.parser.parse(sample_python_simple_error)
|
||||
explanation = self.explainer.explain(parsed)
|
||||
|
||||
if "code_examples" in explanation:
|
||||
assert isinstance(explanation["code_examples"], list)
|
||||
|
||||
def test_explain_simple(self, sample_python_simple_error):
|
||||
"""Test simple text explanation."""
|
||||
result = self.explainer.explain_simple(
|
||||
"ValueError",
|
||||
"invalid value for int()",
|
||||
"python"
|
||||
)
|
||||
|
||||
assert "Error: ValueError" in result
|
||||
assert "Language: python" in result
|
||||
assert "What happened:" in result
|
||||
assert "How to fix:" in result
|
||||
|
||||
def test_get_fix_steps(self, sample_python_simple_error):
|
||||
"""Test getting fix steps for an error."""
|
||||
parsed = self.parser.parse(sample_python_simple_error)
|
||||
steps = self.explainer.get_fix_steps(parsed)
|
||||
|
||||
assert isinstance(steps, list)
|
||||
assert len(steps) > 0
|
||||
|
||||
def test_explain_unknown_error(self, sample_unknown_error):
|
||||
"""Test explaining an unknown error type."""
|
||||
parsed = self.parser.parse(sample_unknown_error)
|
||||
explanation = self.explainer.explain(parsed)
|
||||
|
||||
assert "error_type" in explanation
|
||||
assert "what_happened" in explanation
|
||||
assert "how_to_fix" in explanation
|
||||
|
||||
|
||||
class TestExplainerSummary:
|
||||
"""Test cases for explanation summary generation."""
|
||||
|
||||
def test_summary_format(self, sample_python_simple_error):
|
||||
"""Test summary format is correct."""
|
||||
parser = ErrorParser()
|
||||
kb = KnowledgeBase()
|
||||
explainer = Explainer(kb)
|
||||
|
||||
parsed = parser.parse(sample_python_simple_error)
|
||||
explanation = explainer.explain(parsed)
|
||||
|
||||
summary = explanation["summary"]
|
||||
assert "ValueError" in summary
|
||||
assert "python" in summary
|
||||
214
tests/test_generators.py
Normal file
214
tests/test_generators.py
Normal file
@@ -0,0 +1,214 @@
|
||||
"""Tests for generators module."""
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from doc2man.generators.man import generate_man_page, ManPageValidator, get_man_title
|
||||
from doc2man.generators.markdown import generate_markdown, MarkdownValidator, get_md_title
|
||||
from doc2man.generators.html import generate_html, HTMLValidator, get_html_title
|
||||
|
||||
|
||||
class TestManPageGenerator:
|
||||
"""Tests for man page generator."""
|
||||
|
||||
def test_generate_man_page_basic(self):
|
||||
"""Test basic man page generation."""
|
||||
data = [
|
||||
{
|
||||
"file": "example.py",
|
||||
"data": {
|
||||
"title": "Example Command",
|
||||
"description": "An example command for testing.",
|
||||
"functions": [
|
||||
{
|
||||
"name": "example",
|
||||
"description": "An example function.",
|
||||
"args": [
|
||||
{"name": "--input", "type": "string", "description": "Input file path"}
|
||||
],
|
||||
"examples": ["example --input file.txt"]
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as f:
|
||||
output_path = Path(f.name)
|
||||
result = generate_man_page(data, output_path)
|
||||
|
||||
assert ".TH" in result
|
||||
assert "EXAMPLE" in result
|
||||
assert "NAME" in result
|
||||
assert "example" in result.lower()
|
||||
|
||||
output_path.unlink()
|
||||
|
||||
def test_man_page_validator(self):
|
||||
"""Test man page validation."""
|
||||
content = """
|
||||
.TH EXAMPLE 1
|
||||
.SH NAME
|
||||
example \- An example command
|
||||
.SH DESCRIPTION
|
||||
This is a description.
|
||||
"""
|
||||
warnings = ManPageValidator.validate(content)
|
||||
|
||||
assert len(warnings) == 0
|
||||
|
||||
def test_man_page_validator_missing_th(self):
|
||||
"""Test validation with missing .TH macro."""
|
||||
content = """
|
||||
.SH NAME
|
||||
example \- An example command
|
||||
.SH DESCRIPTION
|
||||
This is a description.
|
||||
"""
|
||||
warnings = ManPageValidator.validate(content)
|
||||
|
||||
assert any("TH" in w for w in warnings)
|
||||
|
||||
def test_get_man_title(self):
|
||||
"""Test extracting man page title."""
|
||||
data = [{"data": {"title": "Test Command"}}]
|
||||
assert get_man_title(data) == "Test Command"
|
||||
|
||||
data = [{"data": {"functions": [{"name": "func1"}]}}]
|
||||
assert get_man_title(data) == "func1"
|
||||
|
||||
|
||||
class TestMarkdownGenerator:
|
||||
"""Tests for markdown generator."""
|
||||
|
||||
def test_generate_markdown_basic(self):
|
||||
"""Test basic markdown generation."""
|
||||
data = [
|
||||
{
|
||||
"file": "example.py",
|
||||
"data": {
|
||||
"title": "Example Command",
|
||||
"description": "An example command for testing.",
|
||||
"functions": [
|
||||
{
|
||||
"name": "example",
|
||||
"description": "An example function.",
|
||||
"args": [
|
||||
{"name": "input", "type": "string", "description": "Input file"}
|
||||
],
|
||||
"returns": {"type": "str", "description": "Result string"},
|
||||
"examples": ["example()"]
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as f:
|
||||
output_path = Path(f.name)
|
||||
result = generate_markdown(data, output_path)
|
||||
|
||||
assert "# Example Command" in result
|
||||
assert "## Functions" in result
|
||||
assert "### `example`" in result
|
||||
assert "Parameters" in result
|
||||
assert "| `input` |" in result
|
||||
|
||||
output_path.unlink()
|
||||
|
||||
def test_markdown_validator(self):
|
||||
"""Test markdown validation."""
|
||||
content = """# Title
|
||||
|
||||
Some content.
|
||||
"""
|
||||
warnings = MarkdownValidator.validate(content)
|
||||
assert len(warnings) == 0
|
||||
|
||||
def test_markdown_validator_no_header(self):
|
||||
"""Test validation with no header."""
|
||||
content = """Some content without header.
|
||||
"""
|
||||
warnings = MarkdownValidator.validate(content)
|
||||
|
||||
assert any("header" in w.lower() for w in warnings)
|
||||
|
||||
def get_md_title(self):
|
||||
"""Test extracting markdown title."""
|
||||
data = [{"data": {"title": "Test Doc"}}]
|
||||
assert get_md_title(data) == "Test Doc"
|
||||
|
||||
|
||||
class TestHTMLGenerator:
|
||||
"""Tests for HTML generator."""
|
||||
|
||||
def test_generate_html_basic(self):
|
||||
"""Test basic HTML generation."""
|
||||
data = [
|
||||
{
|
||||
"file": "example.py",
|
||||
"data": {
|
||||
"title": "Example Command",
|
||||
"description": "An example command for testing.",
|
||||
"functions": [
|
||||
{
|
||||
"name": "example",
|
||||
"description": "An example function.",
|
||||
"args": [
|
||||
{"name": "input", "type": "string", "description": "Input file"}
|
||||
],
|
||||
"examples": ["example()"]
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
|
||||
output_path = Path(f.name)
|
||||
result = generate_html(data, output_path)
|
||||
|
||||
assert "<!DOCTYPE html>" in result
|
||||
assert "<title>Example Command</title>" in result
|
||||
assert "<h1>Example Command</h1>" in result
|
||||
assert "<h3 id=\"example\">example</h3>" in result
|
||||
assert "<table>" in result
|
||||
|
||||
output_path.unlink()
|
||||
|
||||
def test_html_validator(self):
|
||||
"""Test HTML validation."""
|
||||
content = """<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Test</title>
|
||||
</head>
|
||||
<body>
|
||||
Content
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
warnings = HTMLValidator.validate(content)
|
||||
assert len(warnings) == 0
|
||||
|
||||
def test_html_validator_missing_doctype(self):
|
||||
"""Test validation with missing DOCTYPE."""
|
||||
content = """<html>
|
||||
<head>
|
||||
<title>Test</title>
|
||||
</head>
|
||||
<body>
|
||||
Content
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
warnings = HTMLValidator.validate(content)
|
||||
|
||||
assert any("DOCTYPE" in w for w in warnings)
|
||||
|
||||
def get_html_title(self):
|
||||
"""Test extracting HTML title."""
|
||||
data = [{"data": {"title": "Test Doc"}}]
|
||||
assert get_html_title(data) == "Test Doc"
|
||||
234
tests/test_integration.py
Normal file
234
tests/test_integration.py
Normal file
@@ -0,0 +1,234 @@
|
||||
"""Integration tests for the diff auditor."""
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from git import Repo
|
||||
|
||||
from cli_diff_auditor.cli import main
|
||||
from cli_diff_auditor.hook import PreCommitHookManager
|
||||
|
||||
|
||||
class TestGitIntegration:
|
||||
"""Integration tests with git repository."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.runner = CliRunner()
|
||||
|
||||
@pytest.fixture
|
||||
def temp_repo(self):
|
||||
"""Create a temporary git repository."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
repo = Repo.init(tmpdir)
|
||||
yield tmpdir, repo
|
||||
|
||||
def test_audit_in_empty_repo(self, temp_repo):
|
||||
"""Test audit in a repository with no commits."""
|
||||
tmpdir, repo = temp_repo
|
||||
|
||||
result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_audit_with_staged_debug_print(self, temp_repo):
|
||||
"""Test audit detects staged debug print."""
|
||||
tmpdir, repo = temp_repo
|
||||
|
||||
test_file = Path(tmpdir) / "test.py"
|
||||
test_file.write_text("print('hello')\n")
|
||||
|
||||
repo.index.add(["test.py"])
|
||||
repo.index.commit("Initial commit")
|
||||
|
||||
test_file.write_text("print('world')\n")
|
||||
repo.index.add(["test.py"])
|
||||
|
||||
result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_hook_install_and_check(self, temp_repo):
|
||||
"""Test installing and checking the hook."""
|
||||
tmpdir, repo = temp_repo
|
||||
|
||||
manager = PreCommitHookManager()
|
||||
result = manager.install_hook(tmpdir)
|
||||
|
||||
assert result.success is True
|
||||
|
||||
installed = manager.check_hook_installed(tmpdir)
|
||||
assert installed is True
|
||||
|
||||
def test_hook_remove(self, temp_repo):
|
||||
"""Test removing the hook."""
|
||||
tmpdir, repo = temp_repo
|
||||
|
||||
manager = PreCommitHookManager()
|
||||
manager.install_hook(tmpdir)
|
||||
|
||||
result = manager.remove_hook(tmpdir)
|
||||
|
||||
assert result.success is True
|
||||
assert manager.check_hook_installed(tmpdir) is False
|
||||
|
||||
|
||||
class TestAutoFixIntegration:
|
||||
"""Integration tests for auto-fix functionality."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.runner = CliRunner()
|
||||
|
||||
def test_fix_trailing_whitespace_integration(self):
|
||||
"""Test fixing trailing whitespace in actual file."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("def hello():\n return 'world' \n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
result = self.runner.invoke(main, ["fix", temp_path])
|
||||
|
||||
assert result.exit_code == 0
|
||||
content = Path(temp_path).read_text()
|
||||
assert content == "def hello():\n return 'world'\n"
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_fix_notimplemented_integration(self):
|
||||
"""Test fixing NotImplemented in actual file."""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("def foo():\n raise NotImplemented\n")
|
||||
temp_path = f.name
|
||||
|
||||
try:
|
||||
from cli_diff_auditor.autofix import AutoFixer
|
||||
fixer = AutoFixer()
|
||||
result = fixer.fix_notimplemented_error(temp_path)
|
||||
|
||||
assert result.success is True
|
||||
content = Path(temp_path).read_text()
|
||||
assert "raise NotImplementedError" in content
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
|
||||
class TestConfigurationIntegration:
|
||||
"""Integration tests for configuration loading."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.runner = CliRunner()
|
||||
|
||||
def test_load_custom_rules(self):
|
||||
"""Test loading custom rules from config."""
|
||||
config_content = """
|
||||
rules:
|
||||
- id: custom-test
|
||||
name: Custom Test
|
||||
description: A custom test rule
|
||||
pattern: "CUSTOM.*"
|
||||
severity: warning
|
||||
category: custom
|
||||
"""
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
|
||||
f.write(config_content)
|
||||
config_path = f.name
|
||||
|
||||
try:
|
||||
result = self.runner.invoke(main, ["--config", config_path, "rules"])
|
||||
|
||||
assert result.exit_code == 0
|
||||
assert "custom-test" in result.output
|
||||
finally:
|
||||
os.unlink(config_path)
|
||||
|
||||
def test_nonexistent_config(self):
|
||||
"""Test handling non-existent config file."""
|
||||
result = self.runner.invoke(main, ["--config", "/nonexistent/config.yaml", "rules"])
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
|
||||
class TestEdgeCasesIntegration:
|
||||
"""Integration tests for edge cases."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.runner = CliRunner()
|
||||
|
||||
def test_empty_diff_audit(self):
|
||||
"""Test auditing empty diff."""
|
||||
result = self.runner.invoke(main, ["audit-diff", ""])
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_audit_binary_file_ignored(self, temp_repo):
|
||||
"""Test that binary files are skipped."""
|
||||
tmpdir, repo = temp_repo
|
||||
|
||||
test_file = Path(tmpdir) / "image.png"
|
||||
test_file.write_bytes(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR")
|
||||
|
||||
repo.index.add(["image.png"])
|
||||
repo.index.commit("Add binary file")
|
||||
|
||||
result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_audit_multiple_files(self, temp_repo):
|
||||
"""Test auditing multiple files."""
|
||||
tmpdir, repo = temp_repo
|
||||
|
||||
file1 = Path(tmpdir) / "file1.py"
|
||||
file1.write_text("print('hello')\n")
|
||||
file2 = Path(tmpdir) / "file2.py"
|
||||
file2.write_text("console.log('world')\n")
|
||||
|
||||
repo.index.add(["file1.py", "file2.py"])
|
||||
repo.index.commit("Add files")
|
||||
|
||||
file1.write_text("print('updated')\n")
|
||||
file2.write_text("console.log('updated')\n")
|
||||
repo.index.add(["file1.py", "file2.py"])
|
||||
|
||||
result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
@pytest.fixture
|
||||
def temp_repo(self):
|
||||
"""Create a temporary git repository."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
repo = Repo.init(tmpdir)
|
||||
yield tmpdir, repo
|
||||
|
||||
|
||||
class TestCLIFailLevel:
|
||||
"""Test CLI fail level option."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.runner = CliRunner()
|
||||
|
||||
def test_fail_level_error(self):
|
||||
"""Test fail-level error option."""
|
||||
result = self.runner.invoke(main, ["check", "--fail-level", "error"])
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_fail_level_warning(self):
|
||||
"""Test fail-level warning option."""
|
||||
result = self.runner.invoke(main, ["check", "--fail-level", "warning"])
|
||||
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_fail_level_info(self):
|
||||
"""Test fail-level info option."""
|
||||
result = self.runner.invoke(main, ["check", "--fail-level", "info"])
|
||||
|
||||
assert result.exit_code == 0
|
||||
103
tests/test_interactive.py
Normal file
103
tests/test_interactive.py
Normal file
@@ -0,0 +1,103 @@
|
||||
"""Tests for interactive mode."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def setup_test_env(tmp_path, sample_docker_yaml, sample_git_yaml):
|
||||
"""Set up test environment."""
|
||||
docker_file = tmp_path / "docker.yaml"
|
||||
docker_file.write_text(sample_docker_yaml)
|
||||
|
||||
git_file = tmp_path / "git.yaml"
|
||||
git_file.write_text(sample_git_yaml)
|
||||
|
||||
os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
|
||||
os.environ["SHELL_SPEAK_HISTORY_FILE"] = str(tmp_path / "history.json")
|
||||
os.environ["SHELL_SPEAK_CORRECTIONS_FILE"] = str(tmp_path / "corrections.json")
|
||||
|
||||
|
||||
class TestInteractiveSession:
|
||||
"""Tests for interactive session functionality."""
|
||||
|
||||
def test_session_prompt(self):
|
||||
"""Test that session prompt is created."""
|
||||
from shell_speak.interactive import ShellSpeakCompleter
|
||||
|
||||
completer = ShellSpeakCompleter()
|
||||
assert completer is not None
|
||||
|
||||
def test_key_bindings(self):
|
||||
"""Test key bindings creation."""
|
||||
from shell_speak.interactive import create_key_bindings
|
||||
|
||||
kb = create_key_bindings()
|
||||
assert kb is not None
|
||||
|
||||
def test_detect_tool_docker(self):
|
||||
"""Test tool detection for docker."""
|
||||
from shell_speak.interactive import _detect_tool
|
||||
|
||||
tool = _detect_tool("list running containers")
|
||||
assert tool == "docker"
|
||||
|
||||
def test_detect_tool_git(self):
|
||||
"""Test tool detection for git."""
|
||||
from shell_speak.interactive import _detect_tool
|
||||
|
||||
tool = _detect_tool("commit changes with message")
|
||||
assert tool == "git"
|
||||
|
||||
def test_detect_tool_kubectl(self):
|
||||
"""Test tool detection for kubectl."""
|
||||
from shell_speak.interactive import _detect_tool
|
||||
|
||||
tool = _detect_tool("get pods in namespace default")
|
||||
assert tool == "kubectl"
|
||||
|
||||
def test_detect_tool_unknown(self):
|
||||
"""Test tool detection for unknown query."""
|
||||
from shell_speak.interactive import _detect_tool
|
||||
|
||||
tool = _detect_tool("random query that matches nothing")
|
||||
assert tool is None
|
||||
|
||||
|
||||
class TestInteractiveHelp:
|
||||
"""Tests for interactive help."""
|
||||
|
||||
def test_help_display(self):
|
||||
"""Test help message display."""
|
||||
from shell_speak.interactive import _show_interactive_help
|
||||
from shell_speak.output import console
|
||||
|
||||
with patch.object(console, 'print') as mock_print:
|
||||
_show_interactive_help()
|
||||
assert mock_print.called
|
||||
|
||||
|
||||
class TestProcessQuery:
|
||||
"""Tests for query processing."""
|
||||
|
||||
def test_process_query_success(self, setup_test_env):
|
||||
"""Test successful query processing."""
|
||||
from shell_speak.interactive import _process_query
|
||||
|
||||
match = _process_query("list running containers", "docker")
|
||||
|
||||
if match:
|
||||
assert "docker" in match.command.lower()
|
||||
|
||||
def test_process_query_failure(self, setup_test_env):
|
||||
"""Test failed query processing."""
|
||||
from shell_speak.interactive import _process_query
|
||||
|
||||
match = _process_query("xyz unknown query xyz", None)
|
||||
assert match is None
|
||||
178
tests/test_parser.py
Normal file
178
tests/test_parser.py
Normal file
@@ -0,0 +1,178 @@
|
||||
"""Tests for the parser module."""
|
||||
|
||||
from cli_explain_fix.parser import ErrorParser, ParsedError
|
||||
|
||||
|
||||
class TestErrorParser:
|
||||
"""Test cases for ErrorParser."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up parser instance for each test."""
|
||||
self.parser = ErrorParser()
|
||||
|
||||
def test_detect_language_python_traceback(self, sample_python_traceback):
|
||||
"""Test language detection for Python traceback."""
|
||||
lang = self.parser.detect_language(sample_python_traceback)
|
||||
assert lang == "python"
|
||||
|
||||
def test_detect_language_python_simple(self, sample_python_simple_error):
|
||||
"""Test language detection for simple Python error."""
|
||||
lang = self.parser.detect_language(sample_python_simple_error)
|
||||
assert lang == "python"
|
||||
|
||||
def test_detect_language_javascript(self, sample_js_error):
|
||||
"""Test language detection for JavaScript error."""
|
||||
lang = self.parser.detect_language(sample_js_error)
|
||||
assert lang == "javascript"
|
||||
|
||||
def test_detect_language_go(self, sample_go_panic):
|
||||
"""Test language detection for Go panic."""
|
||||
lang = self.parser.detect_language(sample_go_panic)
|
||||
assert lang == "go"
|
||||
|
||||
def test_detect_language_rust(self, sample_rust_panic):
|
||||
"""Test language detection for Rust panic."""
|
||||
lang = self.parser.detect_language(sample_rust_panic)
|
||||
assert lang == "rust"
|
||||
|
||||
def test_detect_language_json(self, sample_json_error):
|
||||
"""Test language detection for JSON error."""
|
||||
lang = self.parser.detect_language(sample_json_error)
|
||||
assert lang == "json"
|
||||
|
||||
def test_detect_language_yaml(self, sample_yaml_error):
|
||||
"""Test language detection for YAML error."""
|
||||
lang = self.parser.detect_language(sample_yaml_error)
|
||||
assert lang == "yaml"
|
||||
|
||||
def test_detect_language_cli(self, sample_cli_error):
|
||||
"""Test language detection for CLI error."""
|
||||
lang = self.parser.detect_language(sample_cli_error)
|
||||
assert lang == "cli"
|
||||
|
||||
def test_detect_language_unknown(self, sample_unknown_error):
|
||||
"""Test language detection for unknown error."""
|
||||
lang = self.parser.detect_language(sample_unknown_error)
|
||||
assert lang == "unknown"
|
||||
|
||||
def test_parse_python_traceback(self, sample_python_traceback):
|
||||
"""Test parsing Python traceback."""
|
||||
result = self.parser.parse(sample_python_traceback)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "ModuleNotFoundError"
|
||||
assert result.language == "python"
|
||||
assert "requests" in result.message
|
||||
assert result.file_name == "/app/main.py"
|
||||
assert result.line_number == 10
|
||||
assert len(result.stack_frames) > 0
|
||||
|
||||
def test_parse_python_simple(self, sample_python_simple_error):
|
||||
"""Test parsing simple Python error."""
|
||||
result = self.parser.parse(sample_python_simple_error)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "ValueError"
|
||||
assert result.language == "python"
|
||||
assert "invalid value" in result.message
|
||||
|
||||
def test_parse_javascript_error(self, sample_js_error):
|
||||
"""Test parsing JavaScript error."""
|
||||
result = self.parser.parse(sample_js_error)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "TypeError"
|
||||
assert result.language == "javascript"
|
||||
|
||||
def test_parse_go_panic(self, sample_go_panic):
|
||||
"""Test parsing Go panic."""
|
||||
result = self.parser.parse(sample_go_panic)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "panic"
|
||||
assert result.language == "go"
|
||||
|
||||
def test_parse_rust_panic(self, sample_rust_panic):
|
||||
"""Test parsing Rust panic."""
|
||||
result = self.parser.parse(sample_rust_panic)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "panic"
|
||||
assert result.language == "rust"
|
||||
|
||||
def test_parse_json_error(self, sample_json_error):
|
||||
"""Test parsing JSON error."""
|
||||
result = self.parser.parse(sample_json_error)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "JSONParseError"
|
||||
assert result.language == "json"
|
||||
|
||||
def test_parse_yaml_error(self, sample_yaml_error):
|
||||
"""Test parsing YAML error."""
|
||||
result = self.parser.parse(sample_yaml_error)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "YAMLParseError"
|
||||
assert result.language == "yaml"
|
||||
|
||||
def test_parse_cli_error(self, sample_cli_error):
|
||||
"""Test parsing CLI error."""
|
||||
result = self.parser.parse(sample_cli_error)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "GenericError"
|
||||
assert result.language == "cli"
|
||||
|
||||
def test_parse_with_explicit_language(self, sample_python_simple_error):
|
||||
"""Test parsing with explicit language specification."""
|
||||
result = self.parser.parse(sample_python_simple_error, language="python")
|
||||
|
||||
assert result.language == "python"
|
||||
assert result.error_type == "ValueError"
|
||||
|
||||
def test_parse_unknown_error(self, sample_unknown_error):
|
||||
"""Test parsing unknown error returns default."""
|
||||
result = self.parser.parse(sample_unknown_error)
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "UnknownError"
|
||||
assert result.language == "unknown"
|
||||
|
||||
def test_parse_empty_input(self):
|
||||
"""Test parsing empty input."""
|
||||
result = self.parser.parse("")
|
||||
|
||||
assert isinstance(result, ParsedError)
|
||||
assert result.error_type == "UnknownError"
|
||||
assert result.message == "Unknown error occurred"
|
||||
|
||||
def test_parsed_error_to_dict(self, sample_python_simple_error):
|
||||
"""Test ParsedError.to_dict() method."""
|
||||
result = self.parser.parse(sample_python_simple_error)
|
||||
data = result.to_dict()
|
||||
|
||||
assert isinstance(data, dict)
|
||||
assert "error_type" in data
|
||||
assert "message" in data
|
||||
assert "language" in data
|
||||
assert "stack_frames" in data
|
||||
|
||||
def test_parse_complex_python_traceback(self):
|
||||
"""Test parsing complex Python traceback with multiple frames."""
|
||||
traceback = '''Traceback (most recent call last):
|
||||
File "app.py", line 5, in <module>
|
||||
main()
|
||||
File "app.py", line 10, in main
|
||||
process()
|
||||
File "processor.py", line 20, in process
|
||||
result = data['key']
|
||||
KeyError: 'key'
|
||||
'''
|
||||
result = self.parser.parse(traceback)
|
||||
|
||||
assert result.error_type == "KeyError"
|
||||
assert result.language == "python"
|
||||
assert result.file_name == "processor.py"
|
||||
assert result.line_number == 20
|
||||
assert len(result.stack_frames) == 3
|
||||
395
tests/test_parsers.py
Normal file
395
tests/test_parsers.py
Normal file
@@ -0,0 +1,395 @@
|
||||
"""Tests for parsers module."""
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from doc2man.parsers.python import PythonDocstringParser, parse_python_file
|
||||
from doc2man.parsers.go import GoDocstringParser, parse_go_file
|
||||
from doc2man.parsers.javascript import JavaScriptDocstringParser, parse_javascript_file
|
||||
|
||||
|
||||
class TestPythonDocstringParser:
|
||||
"""Tests for Python docstring parser."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.parser = PythonDocstringParser()
|
||||
|
||||
def test_parse_simple_function(self):
|
||||
"""Test parsing a simple function with docstring."""
|
||||
source = '''
|
||||
def hello(name):
|
||||
"""Say hello to a person.
|
||||
|
||||
Args:
|
||||
name: The name of the person to greet.
|
||||
|
||||
Returns:
|
||||
A greeting message.
|
||||
"""
|
||||
return f"Hello, {name}!"
|
||||
'''
|
||||
result = self.parser.parse(source)
|
||||
|
||||
assert len(result["functions"]) == 1
|
||||
func = result["functions"][0]
|
||||
assert func["name"] == "hello"
|
||||
assert "greet" in func["description"].lower() or "hello" in func["description"].lower()
|
||||
assert len(func["args"]) >= 1
|
||||
arg_names = [a["name"] for a in func["args"]]
|
||||
assert "name" in arg_names
|
||||
assert func["returns"] is not None
|
||||
|
||||
def test_parse_function_with_google_style(self):
|
||||
"""Test parsing Google-style docstrings."""
|
||||
source = '''
|
||||
def process_data(items, callback=None):
|
||||
"""Process a list of items with optional callback.
|
||||
|
||||
Args:
|
||||
items: List of items to process.
|
||||
callback: Optional function to call for each item.
|
||||
|
||||
Returns:
|
||||
dict: A dictionary with processed results.
|
||||
|
||||
Raises:
|
||||
ValueError: If items is empty.
|
||||
"""
|
||||
if not items:
|
||||
raise ValueError("Items cannot be empty")
|
||||
return {"count": len(items)}
|
||||
'''
|
||||
result = self.parser.parse(source)
|
||||
|
||||
assert len(result["functions"]) == 1
|
||||
func = result["functions"][0]
|
||||
assert len(func["args"]) >= 2
|
||||
arg_names = [a["name"] for a in func["args"]]
|
||||
assert "items" in arg_names
|
||||
assert "callback" in arg_names
|
||||
assert len(func["raises"]) >= 1
|
||||
raises_names = [r["exception"] for r in func["raises"]]
|
||||
assert "ValueError" in raises_names
|
||||
|
||||
def test_parse_function_with_numpy_style(self):
|
||||
"""Test parsing NumPy-style docstrings."""
|
||||
source = '''
|
||||
def calculate_stats(data):
|
||||
"""Calculate statistics for the given data.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
data : array_like
|
||||
Input data array.
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple
|
||||
A tuple containing (mean, std, median).
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> calculate_stats([1, 2, 3, 4, 5])
|
||||
(3.0, 1.414, 3)
|
||||
"""
|
||||
import numpy as np
|
||||
arr = np.array(data)
|
||||
return arr.mean(), arr.std(), np.median(arr)
|
||||
'''
|
||||
result = self.parser.parse(source)
|
||||
|
||||
func = result["functions"][0]
|
||||
arg_names = [a["name"] for a in func["args"]]
|
||||
assert "data" in arg_names
|
||||
assert len(func["examples"]) > 0
|
||||
|
||||
def test_parse_module_docstring(self):
|
||||
"""Test parsing module-level docstring."""
|
||||
source = '''"""This is a module docstring.
|
||||
|
||||
This module provides utility functions for data processing.
|
||||
"""
|
||||
|
||||
def helper():
|
||||
"""A helper function."""
|
||||
pass
|
||||
'''
|
||||
result = self.parser.parse(source)
|
||||
|
||||
assert "This is a module docstring" in result["module_docstring"]
|
||||
|
||||
def test_parse_class(self):
|
||||
"""Test parsing a class with methods."""
|
||||
source = '''
|
||||
class Calculator:
|
||||
"""A simple calculator class.
|
||||
|
||||
Attributes:
|
||||
memory: Current memory value.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the calculator."""
|
||||
self.memory = 0
|
||||
|
||||
def add(self, a, b):
|
||||
"""Add two numbers.
|
||||
|
||||
Args:
|
||||
a: First number.
|
||||
b: Second number.
|
||||
|
||||
Returns:
|
||||
Sum of a and b.
|
||||
"""
|
||||
return a + b
|
||||
'''
|
||||
result = self.parser.parse(source)
|
||||
|
||||
assert len(result["classes"]) == 1
|
||||
cls = result["classes"][0]
|
||||
assert cls["name"] == "Calculator"
|
||||
assert len(cls["methods"]) == 1
|
||||
assert cls["methods"][0]["name"] == "add"
|
||||
|
||||
def test_parse_file(self):
|
||||
"""Test parsing a Python file."""
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
|
||||
f.write('''
|
||||
def example():
|
||||
"""An example function.
|
||||
|
||||
Returns:
|
||||
None
|
||||
"""
|
||||
pass
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
result = parse_python_file(Path(f.name))
|
||||
|
||||
assert result["language"] == "python"
|
||||
assert len(result["functions"]) == 1
|
||||
|
||||
Path(f.name).unlink()
|
||||
|
||||
|
||||
class TestGoDocstringParser:
|
||||
"""Tests for Go docstring parser."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.parser = GoDocstringParser()
|
||||
|
||||
def test_parse_simple_function(self):
|
||||
"""Test parsing a simple Go function."""
|
||||
source = '''// Add adds two integers and returns the result.
|
||||
//
|
||||
// Parameters:
|
||||
// a: First integer
|
||||
// b: Second integer
|
||||
//
|
||||
// Returns: The sum of a and b
|
||||
func Add(a, b int) int {
|
||||
return a + b
|
||||
}
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
assert len(result["functions"]) == 1
|
||||
func = result["functions"][0]
|
||||
assert func["name"] == "Add"
|
||||
|
||||
def test_parse_function_with_params(self):
|
||||
"""Test parsing Go function with parameters."""
|
||||
source = '''// Greet returns a greeting message.
|
||||
//
|
||||
// name: The name to greet
|
||||
//
|
||||
// Returns: A greeting string
|
||||
func Greet(name string) string {
|
||||
return "Hello, " + name
|
||||
}
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
func = result["functions"][0]
|
||||
assert func["name"] == "Greet"
|
||||
assert len(func["args"]) >= 1
|
||||
arg_names = [a["name"] for a in func["args"]]
|
||||
assert "name" in arg_names
|
||||
|
||||
def test_parse_package_documentation(self):
|
||||
"""Test parsing package-level documentation."""
|
||||
source = '''// Package math provides mathematical utilities.
|
||||
//
|
||||
// This package contains functions for basic
|
||||
// mathematical operations.
|
||||
package math
|
||||
|
||||
// Add adds two numbers.
|
||||
func Add(a, b int) int {
|
||||
return a + b
|
||||
}
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
assert "mathematical utilities" in result["package_docstring"].lower()
|
||||
|
||||
def test_parse_file(self):
|
||||
"""Test parsing a Go file."""
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".go", delete=False) as f:
|
||||
f.write('''// Hello returns a greeting.
|
||||
//
|
||||
// Returns: A greeting message
|
||||
func Hello() string {
|
||||
return "Hello, World!"
|
||||
}
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
result = parse_go_file(Path(f.name))
|
||||
|
||||
assert result["language"] == "go"
|
||||
assert len(result["functions"]) == 1
|
||||
|
||||
Path(f.name).unlink()
|
||||
|
||||
|
||||
class TestJavaScriptDocstringParser:
|
||||
"""Tests for JavaScript docstring parser."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.parser = JavaScriptDocstringParser()
|
||||
|
||||
def test_parse_simple_function(self):
|
||||
"""Test parsing a simple JavaScript function."""
|
||||
source = '''
|
||||
/**
|
||||
* Says hello to a person.
|
||||
*
|
||||
* @param {string} name - The name of the person
|
||||
* @returns {string} A greeting message
|
||||
*/
|
||||
function hello(name) {
|
||||
return "Hello, " + name;
|
||||
}
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
assert len(result["functions"]) == 1
|
||||
func = result["functions"][0]
|
||||
assert func["name"] == "hello"
|
||||
assert "hello" in func["description"].lower() or "person" in func["description"].lower()
|
||||
assert len(func["args"]) >= 1
|
||||
arg_names = [a["name"] for a in func["args"]]
|
||||
assert "name" in arg_names
|
||||
|
||||
def test_parse_arrow_function(self):
|
||||
"""Test parsing an arrow function."""
|
||||
source = '''
|
||||
/**
|
||||
* Adds two numbers.
|
||||
*
|
||||
* @param {number} a - First number
|
||||
* @param {number} b - Second number
|
||||
* @returns {number} The sum
|
||||
*/
|
||||
const add = (a, b) => a + b;
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
func = result["functions"][0]
|
||||
assert func["name"] == "add"
|
||||
assert len(func["args"]) >= 1
|
||||
|
||||
def test_parse_function_with_example(self):
|
||||
"""Test parsing function with examples."""
|
||||
source = '''
|
||||
/**
|
||||
* Squares a number.
|
||||
*
|
||||
* @param {number} n - The number to square
|
||||
* @returns {number} The squared number
|
||||
*
|
||||
* @example
|
||||
* square(5)
|
||||
* // returns 25
|
||||
*/
|
||||
function square(n) {
|
||||
return n * n;
|
||||
}
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
func = result["functions"][0]
|
||||
assert len(func["examples"]) > 0
|
||||
|
||||
def test_parse_export_function(self):
|
||||
"""Test parsing exported function."""
|
||||
source = '''
|
||||
/**
|
||||
* A public API function.
|
||||
*
|
||||
* @returns {void}
|
||||
*/
|
||||
export function publicApi() {
|
||||
console.log("Hello");
|
||||
}
|
||||
'''
|
||||
result = self.parser.parse_content(source)
|
||||
|
||||
assert len(result["functions"]) == 1
|
||||
func = result["functions"][0]
|
||||
assert func["name"] == "publicApi"
|
||||
|
||||
def test_parse_file(self):
|
||||
"""Test parsing a JavaScript file."""
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".js", delete=False) as f:
|
||||
f.write('''
|
||||
/**
|
||||
* Example function.
|
||||
*
|
||||
* @returns {string} A message
|
||||
*/
|
||||
function example() {
|
||||
return "Hello";
|
||||
}
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
result = parse_javascript_file(Path(f.name))
|
||||
|
||||
assert result["language"] == "javascript"
|
||||
assert len(result["functions"]) == 1
|
||||
|
||||
Path(f.name).unlink()
|
||||
|
||||
def test_parse_typescript(self):
|
||||
"""Test parsing a TypeScript file."""
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".ts", delete=False) as f:
|
||||
f.write('''
|
||||
/**
|
||||
* Adds two numbers.
|
||||
*
|
||||
* @param a - First number
|
||||
* @param b - Second number
|
||||
* @returns The sum
|
||||
*/
|
||||
function add(a: number, b: number): number {
|
||||
return a + b;
|
||||
}
|
||||
''')
|
||||
f.flush()
|
||||
|
||||
result = parse_javascript_file(Path(f.name))
|
||||
|
||||
assert len(result["functions"]) >= 1
|
||||
func = result["functions"][0]
|
||||
assert func["returns"] is not None
|
||||
|
||||
Path(f.name).unlink()
|
||||
138
tests/test_pattern_matching.py
Normal file
138
tests/test_pattern_matching.py
Normal file
@@ -0,0 +1,138 @@
|
||||
"""Tests for pattern matching engine."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
|
||||
class TestNLP:
|
||||
"""Tests for NLP preprocessing functions."""
|
||||
|
||||
def test_normalize_text(self):
|
||||
from shell_speak.nlp import normalize_text
|
||||
|
||||
assert normalize_text(" Hello World ") == "hello world"
|
||||
assert normalize_text("Hello\tWorld") == "hello world"
|
||||
assert normalize_text("multiple spaces") == "multiple spaces"
|
||||
|
||||
def test_tokenize(self):
|
||||
from shell_speak.nlp import tokenize
|
||||
|
||||
assert tokenize("hello world") == ["hello", "world"]
|
||||
assert tokenize("List running containers") == ["list", "running", "containers"]
|
||||
assert tokenize("") == []
|
||||
|
||||
def test_extract_keywords(self):
|
||||
from shell_speak.nlp import extract_keywords
|
||||
|
||||
keywords = extract_keywords("list running containers")
|
||||
assert "list" in keywords
|
||||
assert "running" in keywords
|
||||
assert "containers" in keywords
|
||||
|
||||
def test_extract_keywords_removes_stopwords(self):
|
||||
from shell_speak.nlp import extract_keywords
|
||||
|
||||
keywords = extract_keywords("the a is are")
|
||||
assert len(keywords) == 0
|
||||
|
||||
def test_calculate_similarity(self):
|
||||
from shell_speak.nlp import calculate_similarity
|
||||
|
||||
assert calculate_similarity("list containers", "list containers") == 1.0
|
||||
assert calculate_similarity("list containers", "show running containers") > 0.1
|
||||
assert calculate_similarity("list containers", "git commit") == 0.0
|
||||
|
||||
|
||||
class TestPatternMatcher:
|
||||
"""Tests for pattern matching functionality."""
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def setup(self, tmp_path, sample_docker_yaml):
|
||||
from shell_speak.library import get_loader
|
||||
|
||||
docker_file = tmp_path / "docker.yaml"
|
||||
docker_file.write_text(sample_docker_yaml)
|
||||
|
||||
os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
|
||||
|
||||
loader = get_loader()
|
||||
loader._loaded = False
|
||||
loader._patterns = []
|
||||
|
||||
def test_match_existing_pattern(self):
|
||||
from shell_speak.matcher import get_matcher
|
||||
|
||||
matcher = get_matcher()
|
||||
match = matcher.match("list running containers")
|
||||
|
||||
assert match is not None
|
||||
assert match.command == "docker ps"
|
||||
assert match.confidence > 0.5
|
||||
|
||||
def test_match_partial_pattern(self):
|
||||
from shell_speak.matcher import get_matcher
|
||||
|
||||
matcher = get_matcher()
|
||||
match = matcher.match("show running containers")
|
||||
|
||||
assert match is not None
|
||||
assert "docker" in match.command.lower()
|
||||
|
||||
def test_match_no_match(self):
|
||||
from shell_speak.matcher import get_matcher
|
||||
|
||||
matcher = get_matcher()
|
||||
match = matcher.match("xyz unknown query that does not exist")
|
||||
|
||||
assert match is None
|
||||
|
||||
def test_match_with_tool_filter(self):
|
||||
from shell_speak.matcher import get_matcher
|
||||
|
||||
matcher = get_matcher()
|
||||
match = matcher.match("list running containers", tool="docker")
|
||||
|
||||
assert match is not None
|
||||
assert match.pattern.tool == "docker"
|
||||
|
||||
def test_template_substitution(self):
|
||||
from shell_speak.matcher import get_matcher
|
||||
|
||||
matcher = get_matcher()
|
||||
match = matcher.match("run a container named test with image nginx")
|
||||
|
||||
assert match is not None
|
||||
assert "docker" in match.command.lower()
|
||||
|
||||
|
||||
class TestCommandMatch:
|
||||
"""Tests for CommandMatch dataclass."""
|
||||
|
||||
def test_command_match_creation(self):
|
||||
from shell_speak.models import CommandMatch, CommandPattern
|
||||
|
||||
pattern = CommandPattern(
|
||||
name="test_pattern",
|
||||
tool="test",
|
||||
description="Test pattern",
|
||||
patterns=["test query"],
|
||||
template="echo test",
|
||||
explanation="Test explanation",
|
||||
)
|
||||
|
||||
match = CommandMatch(
|
||||
pattern=pattern,
|
||||
confidence=0.9,
|
||||
matched_query="test query",
|
||||
command="echo test",
|
||||
explanation="Test explanation",
|
||||
)
|
||||
|
||||
assert match.pattern.name == "test_pattern"
|
||||
assert match.confidence == 0.9
|
||||
assert match.command == "echo test"
|
||||
150
tests/test_profile.py
Normal file
150
tests/test_profile.py
Normal file
@@ -0,0 +1,150 @@
|
||||
"""Tests for profile management module."""
|
||||
|
||||
import pytest
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class TestProfileManagement:
|
||||
"""Test cases for profile management."""
|
||||
|
||||
def test_get_profiles_dir(self, temp_dir):
|
||||
"""Test getting profiles directory."""
|
||||
from env_pro.core.profile import get_profiles_dir
|
||||
|
||||
profiles_dir = get_profiles_dir(temp_dir)
|
||||
assert profiles_dir == temp_dir / ".env-profiles"
|
||||
|
||||
def test_list_profiles_empty(self, temp_dir):
|
||||
"""Test listing profiles when none exist."""
|
||||
from env_pro.core.profile import list_profiles
|
||||
|
||||
profiles = list_profiles(temp_dir)
|
||||
assert profiles == []
|
||||
|
||||
def test_create_profile(self, temp_dir):
|
||||
"""Test creating a new profile."""
|
||||
from env_pro.core.profile import create_profile, profile_exists, list_profiles
|
||||
|
||||
create_profile("dev", temp_dir)
|
||||
|
||||
assert profile_exists("dev", temp_dir)
|
||||
assert "dev" in list_profiles(temp_dir)
|
||||
|
||||
def test_create_profile_with_env_file(self, temp_dir):
|
||||
"""Test profile creation with .env file."""
|
||||
from env_pro.core.profile import create_profile, get_profile_env_file
|
||||
|
||||
create_profile("staging", temp_dir)
|
||||
|
||||
env_file = get_profile_env_file("staging", temp_dir)
|
||||
assert env_file.exists()
|
||||
|
||||
def test_delete_profile(self, temp_dir):
|
||||
"""Test deleting a profile."""
|
||||
from env_pro.core.profile import create_profile, delete_profile, profile_exists, list_profiles
|
||||
|
||||
create_profile("test", temp_dir)
|
||||
assert profile_exists("test", temp_dir)
|
||||
|
||||
delete_profile("test", temp_dir)
|
||||
assert not profile_exists("test", temp_dir)
|
||||
assert "test" not in list_profiles(temp_dir)
|
||||
|
||||
def test_set_and_get_active_profile(self, temp_dir):
|
||||
"""Test setting and getting active profile."""
|
||||
from env_pro.core.profile import set_active_profile, get_active_profile, create_profile
|
||||
|
||||
create_profile("prod", temp_dir)
|
||||
set_active_profile("prod", temp_dir)
|
||||
|
||||
assert get_active_profile(temp_dir) == "prod"
|
||||
|
||||
def test_set_profile_var(self, temp_dir):
|
||||
"""Test setting a variable in a profile."""
|
||||
from env_pro.core.profile import create_profile, set_profile_var, get_profile_vars
|
||||
|
||||
create_profile("dev", temp_dir)
|
||||
set_profile_var("dev", "DATABASE_URL", "postgresql://localhost:5432/db", temp_dir)
|
||||
|
||||
vars = get_profile_vars("dev", temp_dir)
|
||||
assert vars["DATABASE_URL"] == "postgresql://localhost:5432/db"
|
||||
|
||||
def test_get_profile_vars(self, temp_dir):
|
||||
"""Test getting all variables from a profile."""
|
||||
from env_pro.core.profile import create_profile, set_profile_var, get_profile_vars
|
||||
|
||||
create_profile("dev", temp_dir)
|
||||
set_profile_var("dev", "VAR1", "value1", temp_dir)
|
||||
set_profile_var("dev", "VAR2", "value2", temp_dir)
|
||||
|
||||
vars = get_profile_vars("dev", temp_dir)
|
||||
assert vars["VAR1"] == "value1"
|
||||
assert vars["VAR2"] == "value2"
|
||||
|
||||
def test_delete_profile_var(self, temp_dir):
|
||||
"""Test deleting a variable from a profile."""
|
||||
from env_pro.core.profile import create_profile, set_profile_var, delete_profile_var, get_profile_vars
|
||||
|
||||
create_profile("dev", temp_dir)
|
||||
set_profile_var("dev", "TO_DELETE", "value", temp_dir)
|
||||
assert "TO_DELETE" in get_profile_vars("dev", temp_dir)
|
||||
|
||||
deleted = delete_profile_var("dev", "TO_DELETE", temp_dir)
|
||||
assert deleted
|
||||
assert "TO_DELETE" not in get_profile_vars("dev", temp_dir)
|
||||
|
||||
def test_copy_profile(self, temp_dir):
|
||||
"""Test copying a profile."""
|
||||
from env_pro.core.profile import create_profile, set_profile_var, copy_profile, get_profile_vars
|
||||
|
||||
create_profile("source", temp_dir)
|
||||
set_profile_var("source", "VAR1", "value1", temp_dir)
|
||||
|
||||
from env_pro.core.profile import list_profiles
|
||||
|
||||
copy_profile("source", "dest", temp_dir)
|
||||
|
||||
assert "dest" in list_profiles(temp_dir)
|
||||
assert get_profile_vars("dest", temp_dir)["VAR1"] == "value1"
|
||||
|
||||
def test_diff_profiles(self, temp_dir):
|
||||
"""Test comparing two profiles."""
|
||||
from env_pro.core.profile import create_profile, set_profile_var, diff_profiles
|
||||
|
||||
create_profile("profile1", temp_dir)
|
||||
create_profile("profile2", temp_dir)
|
||||
set_profile_var("profile1", "VAR1", "value1", temp_dir)
|
||||
set_profile_var("profile2", "VAR1", "value2", temp_dir)
|
||||
set_profile_var("profile2", "VAR2", "value2", temp_dir)
|
||||
|
||||
diff = diff_profiles("profile1", "profile2", temp_dir)
|
||||
|
||||
assert "VAR2" in diff["only_in_profile2"]
|
||||
assert diff["different"]["VAR1"] == {"profile1": "value1", "profile2": "value2"}
|
||||
|
||||
|
||||
class TestProfileErrors:
|
||||
"""Test cases for profile errors."""
|
||||
|
||||
def test_create_duplicate_profile(self, temp_dir):
|
||||
"""Test creating a profile that already exists."""
|
||||
from env_pro.core.profile import create_profile, ProfileAlreadyExistsError
|
||||
|
||||
create_profile("dev", temp_dir)
|
||||
|
||||
with pytest.raises(ProfileAlreadyExistsError):
|
||||
create_profile("dev", temp_dir)
|
||||
|
||||
def test_delete_nonexistent_profile(self, temp_dir):
|
||||
"""Test deleting a profile that doesn't exist."""
|
||||
from env_pro.core.profile import delete_profile, ProfileNotFoundError
|
||||
|
||||
with pytest.raises(ProfileNotFoundError):
|
||||
delete_profile("nonexistent", temp_dir)
|
||||
|
||||
def test_switch_to_nonexistent_profile(self, temp_dir):
|
||||
"""Test switching to a non-existent profile."""
|
||||
from env_pro.core.profile import switch_profile, ProfileNotFoundError
|
||||
|
||||
with pytest.raises(ProfileNotFoundError):
|
||||
switch_profile("nonexistent", temp_dir)
|
||||
251
tests/test_rules.py
Normal file
251
tests/test_rules.py
Normal file
@@ -0,0 +1,251 @@
|
||||
"""Tests for the rules module."""
|
||||
|
||||
import pytest
|
||||
from cli_diff_auditor.rules import (
|
||||
BuiltInRules,
|
||||
Finding,
|
||||
Rule,
|
||||
RulesLoader,
|
||||
Severity,
|
||||
)
|
||||
|
||||
|
||||
class TestRule:
|
||||
"""Test cases for Rule class."""
|
||||
|
||||
def test_rule_creation(self):
|
||||
"""Test creating a Rule instance."""
|
||||
rule = Rule(
|
||||
id="test-rule",
|
||||
name="Test Rule",
|
||||
description="A test rule",
|
||||
pattern=r"test.*",
|
||||
severity=Severity.WARNING,
|
||||
auto_fix=True,
|
||||
category="testing"
|
||||
)
|
||||
|
||||
assert rule.id == "test-rule"
|
||||
assert rule.name == "Test Rule"
|
||||
assert rule.severity == Severity.WARNING
|
||||
assert rule.auto_fix is True
|
||||
assert rule.enabled is True
|
||||
|
||||
def test_compile_pattern(self):
|
||||
"""Test compiling a rule pattern."""
|
||||
rule = Rule(
|
||||
id="test",
|
||||
name="Test",
|
||||
description="Test",
|
||||
pattern=r"\bprint\s*\(",
|
||||
severity=Severity.WARNING
|
||||
)
|
||||
|
||||
compiled = rule.compile_pattern()
|
||||
|
||||
assert compiled.search("print('hello')") is not None
|
||||
assert compiled.search("hello world") is None
|
||||
|
||||
def test_get_fix_pattern(self):
|
||||
"""Test getting the fix pattern."""
|
||||
rule = Rule(
|
||||
id="test",
|
||||
name="Test",
|
||||
description="Test",
|
||||
pattern=r"test",
|
||||
severity=Severity.INFO,
|
||||
auto_fix=True,
|
||||
fix_pattern=r"old",
|
||||
replacement="new"
|
||||
)
|
||||
|
||||
fix_pattern = rule.get_fix_pattern()
|
||||
|
||||
assert fix_pattern is not None
|
||||
assert fix_pattern.search("old text") is not None
|
||||
|
||||
|
||||
class TestBuiltInRules:
|
||||
"""Test cases for BuiltInRules class."""
|
||||
|
||||
def test_get_all_rules_returns_list(self):
|
||||
"""Test that get_all_rules returns a list."""
|
||||
rules = BuiltInRules.get_all_rules()
|
||||
|
||||
assert isinstance(rules, list)
|
||||
assert len(rules) > 0
|
||||
|
||||
def test_rules_have_required_fields(self):
|
||||
"""Test that all rules have required fields."""
|
||||
rules = BuiltInRules.get_all_rules()
|
||||
|
||||
for rule in rules:
|
||||
assert rule.id
|
||||
assert rule.name
|
||||
assert rule.description
|
||||
assert rule.pattern
|
||||
assert rule.severity
|
||||
|
||||
def test_debug_rules_exist(self):
|
||||
"""Test that debug-related rules exist."""
|
||||
rules = BuiltInRules.get_all_rules()
|
||||
rule_ids = [r.id for r in rules]
|
||||
|
||||
assert "debug-print" in rule_ids
|
||||
assert "console-log" in rule_ids
|
||||
|
||||
def test_security_rules_exist(self):
|
||||
"""Test that security-related rules exist."""
|
||||
rules = BuiltInRules.get_all_rules()
|
||||
rule_ids = [r.id for r in rules]
|
||||
|
||||
assert "sql-injection" in rule_ids
|
||||
assert "hardcoded-password" in rule_ids
|
||||
assert "eval-usage" in rule_ids
|
||||
|
||||
def test_error_handling_rules_exist(self):
|
||||
"""Test that error handling rules exist."""
|
||||
rules = BuiltInRules.get_all_rules()
|
||||
rule_ids = [r.id for r in rules]
|
||||
|
||||
assert "bare-except" in rule_ids
|
||||
assert "pass-except" in rule_ids
|
||||
|
||||
|
||||
class TestRulesLoader:
|
||||
"""Test cases for RulesLoader class."""
|
||||
|
||||
def setup_method(self):
|
||||
"""Set up test fixtures."""
|
||||
self.loader = RulesLoader()
|
||||
|
||||
def test_load_builtin_rules(self):
|
||||
"""Test loading built-in rules."""
|
||||
self.loader.load_builtin_rules()
|
||||
|
||||
rules = self.loader.get_all_rules()
|
||||
|
||||
assert len(rules) > 0
|
||||
|
||||
def test_get_rule(self):
|
||||
"""Test getting a specific rule."""
|
||||
self.loader.load_builtin_rules()
|
||||
|
||||
rule = self.loader.get_rule("debug-print")
|
||||
|
||||
assert rule is not None
|
||||
assert rule.id == "debug-print"
|
||||
|
||||
def test_get_nonexistent_rule(self):
|
||||
"""Test getting a rule that doesn't exist."""
|
||||
self.loader.load_builtin_rules()
|
||||
|
||||
rule = self.loader.get_rule("nonexistent-rule")
|
||||
|
||||
assert rule is None
|
||||
|
||||
def test_disable_rule(self):
|
||||
"""Test disabling a rule."""
|
||||
self.loader.load_builtin_rules()
|
||||
|
||||
result = self.loader.disable_rule("debug-print")
|
||||
|
||||
assert result is True
|
||||
|
||||
rule = self.loader.get_rule("debug-print")
|
||||
assert rule.enabled is False
|
||||
|
||||
def test_enable_rule(self):
|
||||
"""Test enabling a rule."""
|
||||
self.loader.load_builtin_rules()
|
||||
self.loader.disable_rule("debug-print")
|
||||
|
||||
result = self.loader.enable_rule("debug-print")
|
||||
|
||||
assert result is True
|
||||
|
||||
rule = self.loader.get_rule("debug-print")
|
||||
assert rule.enabled is True
|
||||
|
||||
def test_get_enabled_rules(self):
|
||||
"""Test getting only enabled rules."""
|
||||
self.loader.load_builtin_rules()
|
||||
self.loader.disable_rule("debug-print")
|
||||
self.loader.disable_rule("console-log")
|
||||
|
||||
enabled = self.loader.get_enabled_rules()
|
||||
|
||||
rule_ids = [r.id for r in enabled]
|
||||
|
||||
assert "debug-print" not in rule_ids
|
||||
assert "console-log" not in rule_ids
|
||||
|
||||
def test_load_from_yaml(self):
|
||||
"""Test loading rules from YAML."""
|
||||
self.loader.load_builtin_rules()
|
||||
yaml_content = """
|
||||
rules:
|
||||
- id: custom-rule
|
||||
name: Custom Rule
|
||||
description: A custom rule
|
||||
pattern: "custom.*"
|
||||
severity: warning
|
||||
category: custom
|
||||
"""
|
||||
rules = self.loader.load_from_yaml(yaml_content)
|
||||
|
||||
assert len(rules) == 1
|
||||
assert rules[0].id == "custom-rule"
|
||||
|
||||
all_rules = self.loader.get_all_rules()
|
||||
assert len(all_rules) > 1
|
||||
|
||||
def test_load_from_yaml_minimal(self):
|
||||
"""Test loading rules with minimal fields."""
|
||||
yaml_content = """
|
||||
rules:
|
||||
- id: minimal-rule
|
||||
name: Minimal
|
||||
description: Minimal description
|
||||
pattern: "test"
|
||||
severity: error
|
||||
"""
|
||||
rules = self.loader.load_from_yaml(yaml_content)
|
||||
|
||||
assert len(rules) == 1
|
||||
assert rules[0].severity == Severity.ERROR
|
||||
assert rules[0].auto_fix is False
|
||||
assert rules[0].category == "custom"
|
||||
|
||||
def test_parse_rule_data_missing_required_field(self):
|
||||
"""Test parsing rule data with missing required field."""
|
||||
data = {
|
||||
"id": "test",
|
||||
"name": "Test",
|
||||
"description": "Test"
|
||||
}
|
||||
|
||||
with pytest.raises(ValueError):
|
||||
self.loader._parse_rule_data(data)
|
||||
|
||||
|
||||
class TestFinding:
|
||||
"""Test cases for Finding class."""
|
||||
|
||||
def test_finding_creation(self):
|
||||
"""Test creating a Finding instance."""
|
||||
finding = Finding(
|
||||
rule_id="test-rule",
|
||||
rule_name="Test Rule",
|
||||
severity=Severity.WARNING,
|
||||
file_path="test.py",
|
||||
line_number=10,
|
||||
line_content="print('debug')",
|
||||
message="Debug print statement detected",
|
||||
fix_available=True
|
||||
)
|
||||
|
||||
assert finding.rule_id == "test-rule"
|
||||
assert finding.severity == Severity.WARNING
|
||||
assert finding.line_number == 10
|
||||
assert finding.fix_available is True
|
||||
111
tests/test_template.py
Normal file
111
tests/test_template.py
Normal file
@@ -0,0 +1,111 @@
|
||||
"""Tests for template module."""
|
||||
|
||||
import pytest
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class TestTemplateManagement:
|
||||
"""Test cases for template management."""
|
||||
|
||||
def test_list_builtin_templates(self):
|
||||
"""Test listing builtin templates."""
|
||||
from env_pro.core.template import list_builtin_templates
|
||||
|
||||
templates = list_builtin_templates()
|
||||
assert "fastapi" in templates
|
||||
assert "django" in templates
|
||||
assert "nodejs" in templates
|
||||
assert "python" in templates
|
||||
|
||||
def test_load_builtin_template(self):
|
||||
"""Test loading a builtin template."""
|
||||
from env_pro.core.template import load_template
|
||||
|
||||
content = load_template("minimal")
|
||||
assert "ENVIRONMENT" in content
|
||||
|
||||
def test_get_template_info(self):
|
||||
"""Test getting template information."""
|
||||
from env_pro.core.template import get_template_info
|
||||
|
||||
info = get_template_info("fastapi")
|
||||
assert info["name"] == "fastapi"
|
||||
assert info["type"] == "builtin"
|
||||
assert "APP_NAME" in info["variables"]
|
||||
|
||||
def test_render_template(self):
|
||||
"""Test rendering a template with variables."""
|
||||
from env_pro.core.template import render_template
|
||||
|
||||
content = "APP_NAME=${APP_NAME}\nDEBUG=${DEBUG}"
|
||||
variables = {"APP_NAME": "MyApp", "DEBUG": "true"}
|
||||
rendered = render_template(content, variables)
|
||||
assert "MyApp" in rendered
|
||||
assert "true" in rendered
|
||||
|
||||
def test_render_template_missing_variable(self):
|
||||
"""Test rendering template with missing variable raises error."""
|
||||
from env_pro.core.template import render_template, TemplateSyntaxError
|
||||
|
||||
content = "APP_NAME=${APP_NAME}\nMISSING=${OTHER}"
|
||||
variables = {"APP_NAME": "MyApp"}
|
||||
|
||||
with pytest.raises(TemplateSyntaxError):
|
||||
render_template(content, variables)
|
||||
|
||||
def test_create_and_delete_user_template(self, temp_dir):
|
||||
"""Test creating and deleting a user template."""
|
||||
from env_pro.core.template import (
|
||||
create_template, delete_template, load_template,
|
||||
get_user_templates_dir, list_user_templates
|
||||
)
|
||||
import os
|
||||
|
||||
original_home = os.environ.get("HOME")
|
||||
os.environ["HOME"] = str(temp_dir)
|
||||
|
||||
try:
|
||||
create_template("my-template", "VAR1=value1\nVAR2=value2", "My custom template")
|
||||
|
||||
templates = list_user_templates()
|
||||
assert "my-template" in templates
|
||||
|
||||
loaded = load_template("my-template")
|
||||
assert "VAR1=value1" in loaded
|
||||
|
||||
delete_template("my-template")
|
||||
templates = list_user_templates()
|
||||
assert "my-template" not in templates
|
||||
finally:
|
||||
if original_home:
|
||||
os.environ["HOME"] = original_home
|
||||
else:
|
||||
del os.environ["HOME"]
|
||||
|
||||
def test_apply_template(self, temp_dir):
|
||||
"""Test applying a template to a file."""
|
||||
from env_pro.core.template import apply_template
|
||||
|
||||
output_file = temp_dir / ".env"
|
||||
apply_template("minimal", {"ENVIRONMENT": "production"}, output_file)
|
||||
|
||||
content = output_file.read_text()
|
||||
assert "production" in content
|
||||
|
||||
|
||||
class TestTemplateErrors:
|
||||
"""Test cases for template errors."""
|
||||
|
||||
def test_load_nonexistent_template(self):
|
||||
"""Test loading a template that doesn't exist."""
|
||||
from env_pro.core.template import load_template, TemplateNotFoundError
|
||||
|
||||
with pytest.raises(TemplateNotFoundError):
|
||||
load_template("nonexistent-template")
|
||||
|
||||
def test_delete_builtin_template(self):
|
||||
"""Test that builtin templates cannot be deleted."""
|
||||
from env_pro.core.template import delete_template, TemplateError
|
||||
|
||||
with pytest.raises(TemplateError):
|
||||
delete_template("fastapi")
|
||||
182
tests/test_validator.py
Normal file
182
tests/test_validator.py
Normal file
@@ -0,0 +1,182 @@
|
||||
"""Tests for validation module."""
|
||||
|
||||
import pytest
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class TestSchemaValidation:
|
||||
"""Test cases for schema validation."""
|
||||
|
||||
def test_load_empty_schema(self, temp_dir):
|
||||
"""Test loading schema when no file exists."""
|
||||
from env_pro.core.validator import load_schema
|
||||
|
||||
schema = load_schema(temp_dir)
|
||||
assert schema is None
|
||||
|
||||
def test_load_schema(self, temp_dir):
|
||||
"""Test loading a valid schema."""
|
||||
from env_pro.core.validator import load_schema, EnvSchema
|
||||
|
||||
schema_file = temp_dir / ".env.schema.yaml"
|
||||
schema_file.write_text("""
|
||||
variables:
|
||||
DATABASE_URL:
|
||||
type: url
|
||||
required: true
|
||||
description: Database connection URL
|
||||
DEBUG:
|
||||
type: bool
|
||||
default: false
|
||||
""")
|
||||
|
||||
schema = load_schema(temp_dir)
|
||||
assert schema is not None
|
||||
assert "DATABASE_URL" in schema.variables
|
||||
assert schema.variables["DATABASE_URL"].type == "url"
|
||||
assert schema.variables["DATABASE_URL"].required
|
||||
|
||||
def test_validate_valid_string(self):
|
||||
"""Test validation of valid string value."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="string")
|
||||
errors = validate_value("TEST_VAR", "some-value", schema)
|
||||
assert errors == []
|
||||
|
||||
def test_validate_required_missing(self):
|
||||
"""Test validation when required variable is missing."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="string", required=True)
|
||||
errors = validate_value("TEST_VAR", "", schema)
|
||||
assert len(errors) > 0
|
||||
assert "required" in errors[0].lower()
|
||||
|
||||
def test_validate_int_type(self):
|
||||
"""Test validation of integer type."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="int")
|
||||
errors = validate_value("PORT", "8080", schema)
|
||||
assert errors == []
|
||||
|
||||
errors = validate_value("PORT", "not-a-number", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
def test_validate_bool_type(self):
|
||||
"""Test validation of boolean type."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="bool")
|
||||
errors = validate_value("DEBUG", "true", schema)
|
||||
assert errors == []
|
||||
|
||||
errors = validate_value("DEBUG", "yes", schema)
|
||||
assert errors == []
|
||||
|
||||
def test_validate_email_type(self):
|
||||
"""Test validation of email type."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="email")
|
||||
errors = validate_value("EMAIL", "user@example.com", schema)
|
||||
assert errors == []
|
||||
|
||||
errors = validate_value("EMAIL", "invalid-email", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
def test_validate_url_type(self):
|
||||
"""Test validation of URL type."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="url")
|
||||
errors = validate_value("API_URL", "https://api.example.com", schema)
|
||||
assert errors == []
|
||||
|
||||
errors = validate_value("API_URL", "not-a-url", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
def test_validate_pattern(self):
|
||||
"""Test validation with regex pattern."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="string", pattern=r"^[A-Z]+$")
|
||||
errors = validate_value("PREFIX", "ABC123", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
errors = validate_value("PREFIX", "ABC", schema)
|
||||
assert errors == []
|
||||
|
||||
def test_validate_enum(self):
|
||||
"""Test validation with enum values."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="string", enum=["dev", "staging", "prod"])
|
||||
errors = validate_value("ENV", "dev", schema)
|
||||
assert errors == []
|
||||
|
||||
errors = validate_value("ENV", "invalid", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
def test_validate_min_max_length(self):
|
||||
"""Test validation with min/max length constraints."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="string", min_length=3, max_length=10)
|
||||
errors = validate_value("NAME", "ab", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
errors = validate_value("NAME", "abcdefghijkl", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
errors = validate_value("NAME", "valid", schema)
|
||||
assert errors == []
|
||||
|
||||
def test_validate_min_max_number(self):
|
||||
"""Test validation with min/max number constraints."""
|
||||
from env_pro.core.validator import validate_value, VariableSchema
|
||||
|
||||
schema = VariableSchema(type="int", minimum=1, maximum=100)
|
||||
errors = validate_value("PORT", "0", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
errors = validate_value("PORT", "101", schema)
|
||||
assert len(errors) > 0
|
||||
|
||||
errors = validate_value("PORT", "50", schema)
|
||||
assert errors == []
|
||||
|
||||
def test_validate_env_vars_full(self):
|
||||
"""Test full environment validation."""
|
||||
from env_pro.core.validator import validate_env_vars, EnvSchema, VariableSchema
|
||||
|
||||
schema = EnvSchema(variables={
|
||||
"DATABASE_URL": VariableSchema(type="string", required=True),
|
||||
"DEBUG": VariableSchema(type="bool", default="false")
|
||||
})
|
||||
|
||||
vars_dict = {
|
||||
"DATABASE_URL": "postgresql://localhost:5432/db",
|
||||
"DEBUG": "true"
|
||||
}
|
||||
|
||||
errors = validate_env_vars(vars_dict, schema)
|
||||
assert errors == []
|
||||
|
||||
def test_check_required_vars(self):
|
||||
"""Test checking for missing required variables."""
|
||||
from env_pro.core.validator import check_required_vars, EnvSchema, VariableSchema
|
||||
|
||||
schema = EnvSchema(variables={
|
||||
"REQUIRED_VAR": VariableSchema(type="string", required=True),
|
||||
"OPTIONAL_VAR": VariableSchema(type="string", required=False)
|
||||
})
|
||||
|
||||
vars_dict = {"OPTIONAL_VAR": "value"}
|
||||
missing = check_required_vars(vars_dict, schema)
|
||||
assert "REQUIRED_VAR" in missing
|
||||
|
||||
vars_dict = {"REQUIRED_VAR": "value"}
|
||||
missing = check_required_vars(vars_dict, schema)
|
||||
assert len(missing) == 0
|
||||
0
tests/unit/__init__.py
Normal file
0
tests/unit/__init__.py
Normal file
60
tests/unit/test_cli.py
Normal file
60
tests/unit/test_cli.py
Normal file
@@ -0,0 +1,60 @@
|
||||
"""Unit tests for CLI module."""
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
|
||||
from click.testing import CliRunner
|
||||
|
||||
from codesnap.__main__ import main
|
||||
|
||||
|
||||
class TestCLI:
|
||||
"""Tests for CLI commands."""
|
||||
|
||||
def setup_method(self) -> None:
|
||||
self.runner = CliRunner()
|
||||
|
||||
def test_main_help(self) -> None:
|
||||
result = self.runner.invoke(main, ["--help"])
|
||||
assert result.exit_code == 0
|
||||
assert "CodeSnap" in result.output
|
||||
|
||||
def test_cli_version(self) -> None:
|
||||
result = self.runner.invoke(main, ["--version"])
|
||||
assert result.exit_code == 0
|
||||
assert "0.1.0" in result.output
|
||||
|
||||
def test_cli_analyze_nonexistent_path(self) -> None:
|
||||
result = self.runner.invoke(main, ["analyze", "/nonexistent/path"])
|
||||
assert result.exit_code != 0
|
||||
|
||||
def test_cli_analyze_current_directory(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
with open(os.path.join(tmpdir, "test.py"), "w") as f:
|
||||
f.write("def test(): pass\n")
|
||||
result = self.runner.invoke(main, ["analyze", tmpdir])
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_cli_analyze_with_output_format(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
with open(os.path.join(tmpdir, "test.py"), "w") as f:
|
||||
f.write("def test(): pass\n")
|
||||
result = self.runner.invoke(main, ["analyze", tmpdir, "--format", "json"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_cli_analyze_with_max_files(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
with open(os.path.join(tmpdir, "test.py"), "w") as f:
|
||||
f.write("def test(): pass\n")
|
||||
result = self.runner.invoke(main, ["analyze", tmpdir, "--max-files", "10"])
|
||||
assert result.exit_code == 0
|
||||
|
||||
def test_cli_languages(self) -> None:
|
||||
result = self.runner.invoke(main, ["languages"])
|
||||
assert result.exit_code == 0
|
||||
assert "python" in result.output.lower()
|
||||
|
||||
def test_cli_info_languages(self) -> None:
|
||||
result = self.runner.invoke(main, ["info", "--languages"])
|
||||
assert result.exit_code == 0
|
||||
assert "python" in result.output.lower()
|
||||
269
tests/unit/test_complexity.py
Normal file
269
tests/unit/test_complexity.py
Normal file
@@ -0,0 +1,269 @@
|
||||
"""Unit tests for complexity analysis module."""
|
||||
|
||||
from codesnap.core.complexity import (
|
||||
ComplexityMetrics,
|
||||
analyze_file_complexity,
|
||||
calculate_cyclomatic_complexity,
|
||||
calculate_nesting_depth,
|
||||
count_lines,
|
||||
get_complexity_summary,
|
||||
rate_complexity,
|
||||
)
|
||||
from codesnap.core.parser import FunctionInfo
|
||||
|
||||
|
||||
class TestCalculateCyclomaticComplexity:
|
||||
"""Tests for cyclomatic complexity calculation."""
|
||||
|
||||
def test_empty_content(self):
|
||||
complexity, decisions = calculate_cyclomatic_complexity("")
|
||||
assert complexity == 1
|
||||
assert decisions == 0
|
||||
|
||||
def test_simple_function(self):
|
||||
content = "def test():\n pass"
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity == 1
|
||||
|
||||
def test_if_statement(self):
|
||||
content = "if x > 0:\n pass"
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 1
|
||||
|
||||
def test_multiple_if_statements(self):
|
||||
content = """
|
||||
if x > 0:
|
||||
pass
|
||||
elif x < 0:
|
||||
pass
|
||||
else:
|
||||
pass
|
||||
"""
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 3
|
||||
|
||||
def test_for_loop(self):
|
||||
content = "for i in range(10):\n pass"
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 1
|
||||
|
||||
def test_while_loop(self):
|
||||
content = "while True:\n pass"
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 1
|
||||
|
||||
def test_try_except(self):
|
||||
content = """
|
||||
try:
|
||||
pass
|
||||
except Exception:
|
||||
pass
|
||||
"""
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 1
|
||||
|
||||
def test_and_or_operators(self):
|
||||
content = "if x > 0 and y > 0:\n pass"
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 2
|
||||
|
||||
def test_ternary_operator(self):
|
||||
content = "x = 1 if cond else 2"
|
||||
complexity, decisions = calculate_cyclomatic_complexity(content)
|
||||
assert complexity >= 1
|
||||
|
||||
|
||||
class TestCalculateNestingDepth:
|
||||
"""Tests for nesting depth calculation."""
|
||||
|
||||
def test_flat_code(self):
|
||||
depth = calculate_nesting_depth("x = 1\ny = 2")
|
||||
assert depth >= 0
|
||||
|
||||
def test_single_brace_level(self):
|
||||
depth = calculate_nesting_depth("if x: { y = 1 }")
|
||||
assert depth >= 0
|
||||
|
||||
def test_nested_braces(self):
|
||||
content = """
|
||||
if x:
|
||||
if y:
|
||||
if z:
|
||||
pass
|
||||
"""
|
||||
depth = calculate_nesting_depth(content)
|
||||
assert depth >= 0 # Depends on brace detection
|
||||
|
||||
def test_mixed_brackets(self):
|
||||
content = """
|
||||
def test():
|
||||
data = [
|
||||
[1, 2],
|
||||
{a: b}
|
||||
]
|
||||
"""
|
||||
depth = calculate_nesting_depth(content)
|
||||
assert depth >= 1
|
||||
|
||||
def test_balanced_brackets(self):
|
||||
content = "[](){}"
|
||||
depth = calculate_nesting_depth(content)
|
||||
assert depth >= 1
|
||||
|
||||
def test_unbalanced_close(self):
|
||||
content = "x = 1]"
|
||||
depth = calculate_nesting_depth(content)
|
||||
assert depth >= 0
|
||||
|
||||
|
||||
class TestCountLines:
|
||||
"""Tests for line counting."""
|
||||
|
||||
def test_empty_content(self):
|
||||
total, comments = count_lines("")
|
||||
assert total >= 0
|
||||
assert comments >= 0
|
||||
|
||||
def test_single_line(self):
|
||||
total, comments = count_lines("x = 1")
|
||||
assert total >= 1
|
||||
assert comments >= 0
|
||||
|
||||
def test_python_comments(self):
|
||||
content = "# This is a comment\nx = 1\n# Another comment"
|
||||
total, comments = count_lines(content)
|
||||
assert total >= 3
|
||||
assert comments >= 2
|
||||
|
||||
def test_python_docstring(self):
|
||||
content = '"""This is a docstring"""'
|
||||
total, comments = count_lines(content)
|
||||
assert total >= 1
|
||||
|
||||
def test_multiline_python_comment(self):
|
||||
content = """
|
||||
'''
|
||||
Multiline
|
||||
Comment
|
||||
'''
|
||||
x = 1
|
||||
"""
|
||||
total, comments = count_lines(content)
|
||||
assert total >= 5
|
||||
|
||||
def test_cpp_comments(self):
|
||||
content = "// Single line comment\nx = 1;"
|
||||
total, comments = count_lines(content)
|
||||
assert total >= 2
|
||||
assert comments >= 1
|
||||
|
||||
def test_c_multiline_comment(self):
|
||||
content = "/* Multi\n Line */\nx = 1;"
|
||||
total, comments = count_lines(content)
|
||||
assert total >= 3
|
||||
assert comments >= 1
|
||||
|
||||
|
||||
class TestRateComplexity:
|
||||
"""Tests for complexity rating."""
|
||||
|
||||
def test_low_complexity(self):
|
||||
assert rate_complexity(1, 1) == "low"
|
||||
assert rate_complexity(5, 2) == "low"
|
||||
assert rate_complexity(9, 3) == "low"
|
||||
|
||||
def test_medium_complexity(self):
|
||||
assert rate_complexity(10, 3) == "medium"
|
||||
assert rate_complexity(15, 4) == "medium"
|
||||
assert rate_complexity(19, 5) == "medium"
|
||||
|
||||
def test_high_complexity(self):
|
||||
assert rate_complexity(20, 3) == "high"
|
||||
assert rate_complexity(25, 6) == "high"
|
||||
assert rate_complexity(50, 2) == "high"
|
||||
|
||||
def test_high_nesting(self):
|
||||
result = rate_complexity(5, 6)
|
||||
assert result in ["low", "medium", "high"]
|
||||
|
||||
|
||||
class TestAnalyzeFileComplexity:
|
||||
"""Tests for file complexity analysis."""
|
||||
|
||||
def test_empty_file(self):
|
||||
metrics, func_complexities = analyze_file_complexity("", [], "python")
|
||||
assert metrics.cyclomatic_complexity >= 1
|
||||
assert len(func_complexities) == 0
|
||||
|
||||
def test_simple_file(self):
|
||||
content = "x = 1\ny = 2"
|
||||
metrics, func_complexities = analyze_file_complexity(content, [], "python")
|
||||
assert metrics.complexity_rating in ["low", "medium", "high"]
|
||||
|
||||
def test_complex_file(self):
|
||||
content = """
|
||||
def test():
|
||||
if x > 0:
|
||||
if y > 0:
|
||||
if z > 0:
|
||||
pass
|
||||
"""
|
||||
func = FunctionInfo(
|
||||
name="test",
|
||||
node_type="function",
|
||||
start_line=1,
|
||||
end_line=6,
|
||||
parameters=[],
|
||||
)
|
||||
metrics, func_complexities = analyze_file_complexity(content, [func], "python")
|
||||
assert metrics.complexity_rating in ["low", "medium", "high"]
|
||||
assert len(func_complexities) >= 0
|
||||
|
||||
def test_suggestions_generated(self):
|
||||
content = """
|
||||
def test():
|
||||
pass
|
||||
""" * 25
|
||||
metrics, func_complexities = analyze_file_complexity(content, [], "python")
|
||||
assert isinstance(metrics.suggestions, list)
|
||||
|
||||
|
||||
class TestGetComplexitySummary:
|
||||
"""Tests for complexity summary generation."""
|
||||
|
||||
def test_empty_list(self):
|
||||
summary = get_complexity_summary([])
|
||||
assert summary["total_files"] == 0
|
||||
assert summary["avg_complexity"] == 0
|
||||
|
||||
def test_single_file(self):
|
||||
metrics = ComplexityMetrics(
|
||||
cyclomatic_complexity=10,
|
||||
nesting_depth=2,
|
||||
lines_of_code=50,
|
||||
)
|
||||
summary = get_complexity_summary([metrics])
|
||||
assert summary["total_files"] == 1
|
||||
assert summary["avg_complexity"] == 10
|
||||
|
||||
def test_multiple_files(self):
|
||||
metrics_list = [
|
||||
ComplexityMetrics(cyclomatic_complexity=5),
|
||||
ComplexityMetrics(cyclomatic_complexity=15),
|
||||
ComplexityMetrics(cyclomatic_complexity=10),
|
||||
]
|
||||
summary = get_complexity_summary(metrics_list)
|
||||
assert summary["total_files"] == 3
|
||||
assert summary["avg_complexity"] == 10
|
||||
|
||||
def test_rating_distribution(self):
|
||||
metrics_list = [
|
||||
ComplexityMetrics(cyclomatic_complexity=5),
|
||||
ComplexityMetrics(cyclomatic_complexity=15),
|
||||
ComplexityMetrics(cyclomatic_complexity=25),
|
||||
]
|
||||
summary = get_complexity_summary(metrics_list)
|
||||
assert summary["rating_distribution"]["low"] >= 0
|
||||
assert summary["rating_distribution"]["medium"] >= 0
|
||||
assert summary["rating_distribution"]["high"] >= 0
|
||||
assert summary["rating_distribution"]["low"] + summary["rating_distribution"]["medium"] + summary["rating_distribution"]["high"] == 3
|
||||
71
tests/unit/test_config.py
Normal file
71
tests/unit/test_config.py
Normal file
@@ -0,0 +1,71 @@
|
||||
"""Unit tests for config module."""
|
||||
|
||||
import os
|
||||
|
||||
from codesnap.utils.config import Config, apply_env_overrides, load_config
|
||||
|
||||
|
||||
class TestConfig:
|
||||
"""Tests for Config class."""
|
||||
|
||||
def test_default_values(self) -> None:
|
||||
config = Config()
|
||||
assert config.max_files == 1000
|
||||
assert config.max_tokens == 8000
|
||||
assert config.default_format == "markdown"
|
||||
|
||||
def test_custom_values(self) -> None:
|
||||
config = Config(max_files=500, max_tokens=4000, default_format="json")
|
||||
assert config.max_files == 500
|
||||
assert config.max_tokens == 4000
|
||||
assert config.default_format == "json"
|
||||
|
||||
def test_default_ignore_patterns(self) -> None:
|
||||
config = Config()
|
||||
assert isinstance(config.ignore_patterns, list)
|
||||
|
||||
def test_default_languages(self) -> None:
|
||||
config = Config()
|
||||
assert isinstance(config.included_languages, list)
|
||||
assert isinstance(config.excluded_languages, list)
|
||||
|
||||
|
||||
class TestLoadConfig:
|
||||
"""Tests for load_config function."""
|
||||
|
||||
def test_load_default_config(self) -> None:
|
||||
config = load_config()
|
||||
assert config.max_files == 1000
|
||||
assert config.max_tokens == 8000
|
||||
|
||||
def test_load_nonexistent_file(self) -> None:
|
||||
from pathlib import Path
|
||||
config = load_config(Path("/nonexistent/path.tomll"))
|
||||
assert config.max_files == 1000
|
||||
|
||||
|
||||
class TestApplyEnvOverrides:
|
||||
"""Tests for apply_env_overrides function."""
|
||||
|
||||
def test_no_overrides(self) -> None:
|
||||
config = Config()
|
||||
result = apply_env_overrides(config)
|
||||
assert result.max_files == 1000
|
||||
|
||||
def test_max_files_override(self) -> None:
|
||||
os.environ["CODSNAP_MAX_FILES"] = "500"
|
||||
try:
|
||||
config = Config()
|
||||
result = apply_env_overrides(config)
|
||||
assert result.max_files == 500
|
||||
finally:
|
||||
del os.environ["CODSNAP_MAX_FILES"]
|
||||
|
||||
def test_max_tokens_override(self) -> None:
|
||||
os.environ["CODSNAP_MAX_TOKENS"] = "4000"
|
||||
try:
|
||||
config = Config()
|
||||
result = apply_env_overrides(config)
|
||||
assert result.max_tokens == 4000
|
||||
finally:
|
||||
del os.environ["CODSNAP_MAX_TOKENS"]
|
||||
177
tests/unit/test_dependency_graph.py
Normal file
177
tests/unit/test_dependency_graph.py
Normal file
@@ -0,0 +1,177 @@
|
||||
"""Unit tests for dependency graph module."""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from codesnap.core.dependency_graph import Dependency, DependencyGraphBuilder, DependencyParser
|
||||
|
||||
|
||||
class TestDependencyParser:
|
||||
"""Tests for DependencyParser class."""
|
||||
|
||||
def setup_method(self) -> None:
|
||||
self.parser = DependencyParser()
|
||||
|
||||
def test_parse_python_import(self) -> None:
|
||||
code = "import os"
|
||||
deps = self.parser.parse_file(Path("test.py"), code, "python")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_python_from_import(self) -> None:
|
||||
code = "from pathlib import Path"
|
||||
deps = self.parser.parse_file(Path("test.py"), code, "python")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_python_multiple_imports(self) -> None:
|
||||
code = """
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from collections import defaultdict
|
||||
"""
|
||||
deps = self.parser.parse_file(Path("test.py"), code, "python")
|
||||
assert len(deps) >= 3
|
||||
|
||||
def test_parse_javascript_require(self) -> None:
|
||||
code = "const express = require('express');"
|
||||
deps = self.parser.parse_file(Path("test.js"), code, "javascript")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_javascript_import(self) -> None:
|
||||
code = "import { useState } from 'react';"
|
||||
deps = self.parser.parse_file(Path("test.js"), code, "javascript")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_go_import(self) -> None:
|
||||
code = 'import "fmt"'
|
||||
deps = self.parser.parse_file(Path("test.go"), code, "go")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_rust_use(self) -> None:
|
||||
code = "use std::collections::HashMap;"
|
||||
deps = self.parser.parse_file(Path("test.rs"), code, "rust")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_java_import(self) -> None:
|
||||
code = "import java.util.ArrayList;"
|
||||
deps = self.parser.parse_file(Path("test.java"), code, "java")
|
||||
assert len(deps) >= 1
|
||||
|
||||
def test_parse_unsupported_language(self) -> None:
|
||||
code = "some random code"
|
||||
deps = self.parser.parse_file(Path("test.xyz"), code, "unsupported")
|
||||
assert len(deps) == 0
|
||||
|
||||
|
||||
class TestDependencyGraphBuilder:
|
||||
"""Tests for DependencyGraphBuilder class."""
|
||||
|
||||
def setup_method(self) -> None:
|
||||
self.graph = DependencyGraphBuilder()
|
||||
|
||||
def test_add_file(self) -> None:
|
||||
self.graph.add_file(Path("main.py"), "python", 100, 10, 2, 1)
|
||||
assert self.graph.graph.number_of_nodes() == 1
|
||||
assert Path("main.py") in self.graph.graph.nodes()
|
||||
|
||||
def test_add_dependency(self) -> None:
|
||||
self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("b.py"), "python", 60, 6, 1, 0)
|
||||
|
||||
dep = Dependency(
|
||||
source_file=Path("a.py"),
|
||||
target_file=Path("b.py"),
|
||||
import_statement="import b",
|
||||
import_type="import"
|
||||
)
|
||||
self.graph.add_dependency(dep)
|
||||
|
||||
assert self.graph.graph.has_edge(Path("a.py"), Path("b.py"))
|
||||
|
||||
def test_build_from_analysis(self) -> None:
|
||||
analysis_result = {
|
||||
"files": [
|
||||
{"path": "main.py", "language": "python", "size": 100, "lines": 10, "functions": ["main"], "classes": []},
|
||||
{"path": "utils.py", "language": "python", "size": 50, "lines": 5, "functions": ["helper"], "classes": []}
|
||||
],
|
||||
"dependencies": [
|
||||
{"source": "main.py", "target": "utils.py", "type": "import"}
|
||||
]
|
||||
}
|
||||
self.graph.build_from_analysis(analysis_result)
|
||||
|
||||
assert self.graph.graph.number_of_nodes() == 2
|
||||
assert self.graph.graph.has_edge(Path("main.py"), Path("utils.py"))
|
||||
|
||||
def test_find_cycles(self) -> None:
|
||||
self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("c.py"), "python", 50, 5, 1, 0)
|
||||
|
||||
dep1 = Dependency(Path("a.py"), Path("b.py"), "import b", "import")
|
||||
dep2 = Dependency(Path("b.py"), Path("c.py"), "import c", "import")
|
||||
dep3 = Dependency(Path("c.py"), Path("a.py"), "import a", "import")
|
||||
|
||||
self.graph.add_dependency(dep1)
|
||||
self.graph.add_dependency(dep2)
|
||||
self.graph.add_dependency(dep3)
|
||||
|
||||
cycles = self.graph.find_cycles()
|
||||
assert len(cycles) >= 1
|
||||
|
||||
def test_find_no_cycles(self) -> None:
|
||||
self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
|
||||
|
||||
dep = Dependency(Path("a.py"), Path("b.py"), "import b", "import")
|
||||
self.graph.add_dependency(dep)
|
||||
|
||||
cycles = self.graph.find_cycles()
|
||||
assert len(cycles) == 0
|
||||
|
||||
def test_find_orphaned_files(self) -> None:
|
||||
self.graph.add_file(Path("orphan.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("main.py"), "python", 100, 10, 2, 1)
|
||||
self.graph.add_file(Path("used.py"), "python", 50, 5, 1, 0)
|
||||
|
||||
dep = Dependency(Path("main.py"), Path("used.py"), "import used", "import")
|
||||
self.graph.add_dependency(dep)
|
||||
|
||||
orphaned = self.graph.find_orphaned_files()
|
||||
assert Path("orphan.py") in orphaned
|
||||
assert Path("main.py") not in orphaned
|
||||
assert Path("used.py") not in orphaned
|
||||
|
||||
def test_calculate_metrics(self) -> None:
|
||||
self.graph.add_file(Path("main.py"), "python", 100, 10, 2, 1)
|
||||
self.graph.add_file(Path("utils.py"), "python", 50, 5, 1, 0)
|
||||
|
||||
dep = Dependency(Path("main.py"), Path("utils.py"), "import utils", "import")
|
||||
self.graph.add_dependency(dep)
|
||||
|
||||
metrics = self.graph.calculate_metrics()
|
||||
|
||||
assert metrics.total_files == 2
|
||||
assert metrics.total_edges == 1
|
||||
assert metrics.density >= 0
|
||||
|
||||
def test_get_transitive_closure(self) -> None:
|
||||
self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("c.py"), "python", 50, 5, 1, 0)
|
||||
|
||||
self.graph.add_dependency(Dependency(Path("a.py"), Path("b.py"), "import b", "import"))
|
||||
self.graph.add_dependency(Dependency(Path("b.py"), Path("c.py"), "import c", "import"))
|
||||
|
||||
dependents = self.graph.get_transitive_closure(Path("c.py"))
|
||||
assert len(dependents) >= 0 # May or may not find depending on graph structure
|
||||
|
||||
def test_get_dependencies(self) -> None:
|
||||
self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
|
||||
self.graph.add_file(Path("c.py"), "python", 50, 5, 1, 0)
|
||||
|
||||
self.graph.add_dependency(Dependency(Path("a.py"), Path("b.py"), "import b", "import"))
|
||||
self.graph.add_dependency(Dependency(Path("a.py"), Path("c.py"), "import c", "import"))
|
||||
|
||||
deps = self.graph.get_dependencies(Path("a.py"))
|
||||
assert isinstance(deps, set) # Returns a set
|
||||
112
tests/unit/test_extractor.py
Normal file
112
tests/unit/test_extractor.py
Normal file
@@ -0,0 +1,112 @@
|
||||
from codesnap.core.extractor import FunctionExtractor
|
||||
|
||||
|
||||
class TestFunctionExtractor:
|
||||
def setup_method(self) -> None:
|
||||
self.extractor = FunctionExtractor()
|
||||
|
||||
def test_extract_simple_function(self) -> None:
|
||||
code = """
|
||||
def hello():
|
||||
print("Hello, World!")
|
||||
"""
|
||||
functions = self.extractor.extract_functions_python(code)
|
||||
assert len(functions) >= 1
|
||||
func = functions[0]
|
||||
assert func.name == "hello"
|
||||
assert len(func.parameters) == 0
|
||||
|
||||
def test_extract_function_with_parameters(self) -> None:
|
||||
code = """
|
||||
def greet(name, greeting="Hello"):
|
||||
return f"{greeting}, {name}!"
|
||||
"""
|
||||
functions = self.extractor.extract_functions_python(code)
|
||||
assert len(functions) >= 1
|
||||
func = functions[0]
|
||||
assert func.name == "greet"
|
||||
assert "name" in func.parameters
|
||||
assert "greeting" in func.parameters
|
||||
|
||||
def test_extract_async_function(self) -> None:
|
||||
code = """
|
||||
async def fetch_data(url):
|
||||
async with aiohttp.ClientSession() as session:
|
||||
async with session.get(url) as response:
|
||||
return await response.json()
|
||||
"""
|
||||
functions = self.extractor.extract_functions_python(code)
|
||||
assert len(functions) >= 1
|
||||
func = functions[0]
|
||||
assert func.name == "fetch_data"
|
||||
assert func.is_async is True
|
||||
|
||||
def test_extract_function_with_return_type(self) -> None:
|
||||
code = """
|
||||
def add(a: int, b: int) -> int:
|
||||
return a + b
|
||||
"""
|
||||
functions = self.extractor.extract_functions_python(code)
|
||||
assert len(functions) >= 1
|
||||
func = functions[0]
|
||||
assert func.name == "add"
|
||||
|
||||
def test_extract_function_with_decorator(self) -> None:
|
||||
code = """
|
||||
@property
|
||||
def name(self):
|
||||
return self._name
|
||||
"""
|
||||
functions = self.extractor.extract_functions_python(code)
|
||||
assert len(functions) >= 1
|
||||
|
||||
def test_extract_classes(self) -> None:
|
||||
code = """
|
||||
class MyClass:
|
||||
def __init__(self):
|
||||
self.value = 42
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
"""
|
||||
classes = self.extractor.extract_classes_python(code)
|
||||
assert len(classes) >= 1
|
||||
cls = classes[0]
|
||||
assert cls.name == "MyClass"
|
||||
|
||||
def test_extract_class_with_inheritance(self) -> None:
|
||||
code = """
|
||||
class ChildClass(ParentClass, MixinClass):
|
||||
pass
|
||||
"""
|
||||
classes = self.extractor.extract_classes_python(code)
|
||||
assert len(classes) >= 1
|
||||
cls = classes[0]
|
||||
assert "ParentClass" in cls.base_classes
|
||||
assert "MixinClass" in cls.base_classes
|
||||
|
||||
def test_extract_all_python(self) -> None:
|
||||
code = """
|
||||
def func1():
|
||||
pass
|
||||
|
||||
class MyClass:
|
||||
def method1(self):
|
||||
pass
|
||||
|
||||
def func2():
|
||||
pass
|
||||
"""
|
||||
functions, classes = self.extractor.extract_all(code, "python")
|
||||
assert len(functions) >= 2
|
||||
assert len(classes) >= 1
|
||||
|
||||
def test_extract_from_file(self) -> None:
|
||||
code = """
|
||||
def test_function(x, y):
|
||||
return x + y
|
||||
"""
|
||||
result = self.extractor.extract_from_file("test.py", code, "python")
|
||||
assert result["file"] == "test.py"
|
||||
assert len(result["functions"]) >= 1
|
||||
assert result["functions"][0]["name"] == "test_function"
|
||||
98
tests/unit/test_file_utils.py
Normal file
98
tests/unit/test_file_utils.py
Normal file
@@ -0,0 +1,98 @@
|
||||
from codesnap.utils.file_utils import FileUtils
|
||||
|
||||
|
||||
class TestFileUtils:
|
||||
def test_should_ignore_patterns(self) -> None:
|
||||
assert FileUtils.should_ignore("test.pyc", ["*.pyc"]) is True
|
||||
assert FileUtils.should_ignore("test.pyc", ["*.pyc", "*.pyo"]) is True
|
||||
assert FileUtils.should_ignore("test.py", ["*.pyc"]) is False
|
||||
|
||||
def test_should_ignore_directory(self) -> None:
|
||||
assert FileUtils.should_ignore("src/__pycache__", ["__pycache__/*"]) is True
|
||||
assert FileUtils.should_ignore(".git/config", [".git/*"]) is True
|
||||
|
||||
def test_is_text_file(self) -> None:
|
||||
assert FileUtils.is_text_file("test.py") is True
|
||||
assert FileUtils.is_text_file("test.js") is True
|
||||
assert FileUtils.is_text_file("test.tsx") is True
|
||||
assert FileUtils.is_text_file("Dockerfile") is True
|
||||
|
||||
def test_is_not_binary_file(self) -> None:
|
||||
assert FileUtils.is_text_file("test.png") is False
|
||||
assert FileUtils.is_text_file("test.jpg") is False
|
||||
assert FileUtils.is_text_file("test.so") is False
|
||||
|
||||
def test_read_file_content(self) -> None:
|
||||
import os
|
||||
import tempfile
|
||||
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
|
||||
f.write("print('hello')")
|
||||
temp_path = f.name
|
||||
try:
|
||||
content = FileUtils.read_file_content(temp_path)
|
||||
assert content == "print('hello')"
|
||||
finally:
|
||||
os.unlink(temp_path)
|
||||
|
||||
def test_read_file_content_not_found(self) -> None:
|
||||
content = FileUtils.read_file_content("/nonexistent/file.py")
|
||||
assert content is None
|
||||
|
||||
def test_count_lines(self) -> None:
|
||||
content = "line1\nline2\nline3"
|
||||
assert FileUtils.count_lines(content) == 3
|
||||
assert FileUtils.count_lines("") == 1
|
||||
assert FileUtils.count_lines("single") == 1
|
||||
|
||||
def test_get_relative_path(self) -> None:
|
||||
import os
|
||||
import tempfile
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
subdir = os.path.join(tmpdir, "subdir")
|
||||
os.makedirs(subdir)
|
||||
filepath = os.path.join(subdir, "test.py")
|
||||
rel = FileUtils.get_relative_path(filepath, tmpdir)
|
||||
assert rel == os.path.join("subdir", "test.py")
|
||||
|
||||
def test_walk_directory(self) -> None:
|
||||
import os
|
||||
import tempfile
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
os.makedirs(os.path.join(tmpdir, "src"))
|
||||
os.makedirs(os.path.join(tmpdir, "tests"))
|
||||
with open(os.path.join(tmpdir, "main.py"), "w") as f:
|
||||
f.write("print('hello')")
|
||||
with open(os.path.join(tmpdir, "src", "module.py"), "w") as f:
|
||||
f.write("def test(): pass")
|
||||
|
||||
files = FileUtils.walk_directory(tmpdir, ["*.pyc", "__pycache__/*"], 100)
|
||||
assert len(files) == 2
|
||||
|
||||
def test_walk_directory_with_ignore(self) -> None:
|
||||
import os
|
||||
import tempfile
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
os.makedirs(os.path.join(tmpdir, "__pycache__"))
|
||||
with open(os.path.join(tmpdir, "main.py"), "w") as f:
|
||||
f.write("print('hello')")
|
||||
with open(os.path.join(tmpdir, "__pycache__", "cache.pyc"), "w") as f:
|
||||
f.write("cached")
|
||||
|
||||
files = FileUtils.walk_directory(tmpdir, ["*.pyc", "__pycache__/*"], 100)
|
||||
assert len(files) == 1
|
||||
assert "__pycache__" not in files[0]
|
||||
|
||||
def test_get_directory_tree(self) -> None:
|
||||
import os
|
||||
import tempfile
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
os.makedirs(os.path.join(tmpdir, "src"))
|
||||
os.makedirs(os.path.join(tmpdir, "tests"))
|
||||
with open(os.path.join(tmpdir, "main.py"), "w") as f:
|
||||
f.write("")
|
||||
with open(os.path.join(tmpdir, "src", "module.py"), "w") as f:
|
||||
f.write("")
|
||||
|
||||
tree = FileUtils.get_directory_tree(tmpdir, ["*.pyc"], 3)
|
||||
assert len(tree) > 0
|
||||
assert any("main.py" in line for line in tree)
|
||||
428
tests/unit/test_formatters.py
Normal file
428
tests/unit/test_formatters.py
Normal file
@@ -0,0 +1,428 @@
|
||||
"""Unit tests for output formatters."""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
from codesnap.core.analyzer import AnalysisResult, FileAnalysis
|
||||
from codesnap.core.parser import ClassInfo, FunctionInfo
|
||||
from codesnap.output.json_exporter import export_json, export_json_file
|
||||
from codesnap.output.llm_exporter import (
|
||||
estimate_tokens,
|
||||
export_llm_optimized,
|
||||
truncate_for_token_limit,
|
||||
)
|
||||
from codesnap.output.markdown_exporter import export_markdown, export_markdown_file
|
||||
|
||||
|
||||
class TestJsonExporter:
|
||||
"""Tests for JSON export functionality."""
|
||||
|
||||
def create_test_result(self):
|
||||
"""Create a test analysis result."""
|
||||
func = FunctionInfo(
|
||||
name="test_function",
|
||||
node_type="function_definition",
|
||||
start_line=1,
|
||||
end_line=10,
|
||||
parameters=[{"name": "x", "type": "int"}],
|
||||
return_type="str",
|
||||
is_async=False,
|
||||
)
|
||||
|
||||
cls = ClassInfo(
|
||||
name="TestClass",
|
||||
start_line=1,
|
||||
end_line=20,
|
||||
bases=["BaseClass"],
|
||||
methods=[func],
|
||||
)
|
||||
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/project/main.py"),
|
||||
language="python",
|
||||
size=500,
|
||||
lines=50,
|
||||
functions=[func],
|
||||
classes=[cls],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {
|
||||
"total_files": 1,
|
||||
"total_functions": 1,
|
||||
"total_classes": 1,
|
||||
"total_dependencies": 0,
|
||||
"languages": {"python": 1},
|
||||
}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0.1
|
||||
result.error_count = 0
|
||||
|
||||
return result
|
||||
|
||||
def test_export_json_structure(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
json_output = export_json(result, root)
|
||||
|
||||
data = json.loads(json_output)
|
||||
|
||||
assert "metadata" in data
|
||||
assert "summary" in data
|
||||
assert "files" in data
|
||||
assert "dependencies" in data
|
||||
assert "metrics" in data
|
||||
|
||||
def test_export_json_metadata(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
json_output = export_json(result, root)
|
||||
data = json.loads(json_output)
|
||||
|
||||
assert data["metadata"]["tool"] == "CodeSnap"
|
||||
assert data["metadata"]["version"] == "0.1.0"
|
||||
assert "timestamp" in data["metadata"]
|
||||
assert data["metadata"]["root_path"] == "/test/project"
|
||||
|
||||
def test_export_json_summary(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
json_output = export_json(result, root)
|
||||
data = json.loads(json_output)
|
||||
|
||||
assert data["summary"]["total_files"] == 1
|
||||
assert data["summary"]["total_functions"] == 1
|
||||
assert data["summary"]["total_classes"] == 1
|
||||
|
||||
def test_export_json_functions(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
json_output = export_json(result, root)
|
||||
data = json.loads(json_output)
|
||||
|
||||
assert len(data["files"]) == 1
|
||||
assert len(data["files"][0]["functions"]) == 1
|
||||
assert data["files"][0]["functions"][0]["name"] == "test_function"
|
||||
|
||||
def test_export_json_classes(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
json_output = export_json(result, root)
|
||||
data = json.loads(json_output)
|
||||
|
||||
assert len(data["files"][0]["classes"]) == 1
|
||||
assert data["files"][0]["classes"][0]["name"] == "TestClass"
|
||||
assert data["files"][0]["classes"][0]["bases"] == ["BaseClass"]
|
||||
|
||||
def test_export_json_file(self, tmp_path):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
output_file = tmp_path / "output.json"
|
||||
|
||||
export_json_file(result, root, output_file)
|
||||
|
||||
assert output_file.exists()
|
||||
|
||||
data = json.loads(output_file.read_text())
|
||||
assert "metadata" in data
|
||||
|
||||
|
||||
class TestMarkdownExporter:
|
||||
"""Tests for Markdown export functionality."""
|
||||
|
||||
def create_test_result(self):
|
||||
"""Create a test analysis result."""
|
||||
func = FunctionInfo(
|
||||
name="process_data",
|
||||
node_type="function_definition",
|
||||
start_line=5,
|
||||
end_line=15,
|
||||
parameters=[{"name": "data"}, {"name": "options"}],
|
||||
is_async=True,
|
||||
)
|
||||
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/project/utils.py"),
|
||||
language="python",
|
||||
size=300,
|
||||
lines=30,
|
||||
functions=[func],
|
||||
classes=[],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {
|
||||
"total_files": 1,
|
||||
"total_functions": 1,
|
||||
"total_classes": 0,
|
||||
"total_dependencies": 0,
|
||||
"languages": {"python": 1},
|
||||
}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0.05
|
||||
result.error_count = 0
|
||||
|
||||
return result
|
||||
|
||||
def test_export_markdown_header(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert "# CodeSnap Analysis Report" in md_output
|
||||
|
||||
def test_export_markdown_summary(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert "## Summary" in md_output
|
||||
assert "Total Files" in md_output
|
||||
assert "1" in md_output
|
||||
|
||||
def test_export_markdown_language_breakdown(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert "### Language Breakdown" in md_output
|
||||
assert "python" in md_output.lower()
|
||||
|
||||
def test_export_markdown_file_structure(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert "## File Structure" in md_output
|
||||
assert "```" in md_output
|
||||
|
||||
def test_export_markdown_functions(self):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert "process_data" in md_output
|
||||
assert "async" in md_output.lower()
|
||||
|
||||
def test_export_markdown_file(self, tmp_path):
|
||||
result = self.create_test_result()
|
||||
root = Path("/test/project")
|
||||
output_file = tmp_path / "output.md"
|
||||
|
||||
export_markdown_file(result, root, output_file)
|
||||
|
||||
assert output_file.exists()
|
||||
content = output_file.read_text()
|
||||
assert "# CodeSnap Analysis Report" in content
|
||||
|
||||
def test_empty_result(self):
|
||||
result = AnalysisResult()
|
||||
result.summary = {}
|
||||
result.files = []
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0
|
||||
result.error_count = 0
|
||||
|
||||
root = Path("/test")
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert "# CodeSnap Analysis Report" in md_output
|
||||
|
||||
|
||||
class TestLLMExporter:
|
||||
"""Tests for LLM-optimized export functionality."""
|
||||
|
||||
def test_estimate_tokens_python(self):
|
||||
text = "def hello():\n print('hello')"
|
||||
tokens = estimate_tokens(text, "python")
|
||||
|
||||
assert tokens > 0
|
||||
assert tokens < len(text)
|
||||
|
||||
def test_estimate_tokens_markdown(self):
|
||||
text = "# Heading\n\nSome content here."
|
||||
tokens = estimate_tokens(text, "markdown")
|
||||
|
||||
assert tokens > 0
|
||||
|
||||
def test_truncate_under_limit(self):
|
||||
text = "Short text"
|
||||
result = truncate_for_token_limit(text, 100, "markdown")
|
||||
|
||||
assert result == text
|
||||
|
||||
def test_truncate_over_limit(self):
|
||||
text = "A" * 1000
|
||||
result = truncate_for_token_limit(text, 100, "markdown")
|
||||
|
||||
assert len(result) < len(text)
|
||||
assert "[Output truncated due to token limit]" in result
|
||||
|
||||
def test_export_llm_optimized_structure(self):
|
||||
func = FunctionInfo(
|
||||
name="helper",
|
||||
node_type="function",
|
||||
start_line=1,
|
||||
end_line=5,
|
||||
)
|
||||
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/main.py"),
|
||||
language="python",
|
||||
size=100,
|
||||
lines=10,
|
||||
functions=[func],
|
||||
classes=[],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {
|
||||
"total_files": 1,
|
||||
"total_functions": 1,
|
||||
"total_classes": 0,
|
||||
"total_dependencies": 0,
|
||||
"languages": {"python": 1},
|
||||
}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0.01
|
||||
result.error_count = 0
|
||||
|
||||
root = Path("/test")
|
||||
output = export_llm_optimized(result, root)
|
||||
|
||||
assert "## CODEBASE ANALYSIS SUMMARY" in output
|
||||
assert "### STRUCTURE" in output
|
||||
assert "### KEY COMPONENTS" in output
|
||||
|
||||
def test_export_llm_with_max_tokens(self):
|
||||
func = FunctionInfo(
|
||||
name="test",
|
||||
node_type="function",
|
||||
start_line=1,
|
||||
end_line=5,
|
||||
)
|
||||
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/main.py"),
|
||||
language="python",
|
||||
size=100,
|
||||
lines=10,
|
||||
functions=[func],
|
||||
classes=[],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {
|
||||
"total_files": 1,
|
||||
"total_functions": 1,
|
||||
"total_classes": 0,
|
||||
"total_dependencies": 0,
|
||||
"languages": {"python": 1},
|
||||
}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0.01
|
||||
result.error_count = 0
|
||||
|
||||
root = Path("/test")
|
||||
output = export_llm_optimized(result, root, max_tokens=100)
|
||||
|
||||
tokens = estimate_tokens(output, "markdown")
|
||||
assert tokens <= 100 or "[Output truncated" in output
|
||||
|
||||
|
||||
class TestFormatterIntegration:
|
||||
"""Integration tests for formatters."""
|
||||
|
||||
def test_json_is_valid_json(self):
|
||||
func = FunctionInfo(name="test", node_type="func", start_line=1, end_line=10)
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/main.py"),
|
||||
language="python",
|
||||
size=100,
|
||||
lines=10,
|
||||
functions=[func],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {"total_files": 1}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0
|
||||
|
||||
root = Path("/test")
|
||||
|
||||
json_output = export_json(result, root)
|
||||
|
||||
data = json.loads(json_output)
|
||||
assert data is not None
|
||||
|
||||
def test_markdown_is_readable(self):
|
||||
func = FunctionInfo(name="test", node_type="func", start_line=1, end_line=10)
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/main.py"),
|
||||
language="python",
|
||||
size=100,
|
||||
lines=10,
|
||||
functions=[func],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {"total_files": 1}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0
|
||||
|
||||
root = Path("/test")
|
||||
|
||||
md_output = export_markdown(result, root)
|
||||
|
||||
assert md_output is not None
|
||||
assert len(md_output) > 0
|
||||
assert "#" in md_output
|
||||
|
||||
def test_llm_output_has_summary_first(self):
|
||||
func = FunctionInfo(name="test", node_type="func", start_line=1, end_line=10)
|
||||
file_analysis = FileAnalysis(
|
||||
path=Path("/test/main.py"),
|
||||
language="python",
|
||||
size=100,
|
||||
lines=10,
|
||||
functions=[func],
|
||||
)
|
||||
|
||||
result = AnalysisResult()
|
||||
result.summary = {"total_files": 1}
|
||||
result.files = [file_analysis]
|
||||
result.dependencies = []
|
||||
result.metrics = {}
|
||||
result.analysis_time = 0
|
||||
|
||||
root = Path("/test")
|
||||
|
||||
output = export_llm_optimized(result, root)
|
||||
|
||||
summary_pos = output.find("CODEBASE ANALYSIS SUMMARY")
|
||||
structure_pos = output.find("STRUCTURE")
|
||||
|
||||
assert summary_pos < structure_pos
|
||||
77
tests/unit/test_json_formatter.py
Normal file
77
tests/unit/test_json_formatter.py
Normal file
@@ -0,0 +1,77 @@
|
||||
from codesnap.output.json_formatter import JSONFormatter
|
||||
|
||||
|
||||
class TestJSONFormatter:
|
||||
def setup_method(self) -> None:
|
||||
self.formatter = JSONFormatter()
|
||||
|
||||
def test_format_valid_result(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{
|
||||
"file": "test.py",
|
||||
"language": "python",
|
||||
"lines": 50,
|
||||
"functions": [{"name": "test_func", "start_line": 1, "end_line": 10}],
|
||||
"classes": [],
|
||||
"complexity": {"score": 5, "rating": "low"}
|
||||
}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
import json
|
||||
parsed = json.loads(output)
|
||||
assert "schema_version" in parsed
|
||||
assert "summary" in parsed
|
||||
assert "files" in parsed
|
||||
assert parsed["summary"]["total_files"] == 1
|
||||
|
||||
def test_format_empty_result(self) -> None:
|
||||
result = {
|
||||
"files": [],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
import json
|
||||
parsed = json.loads(output)
|
||||
assert parsed["summary"]["total_files"] == 0
|
||||
|
||||
def test_summary_includes_language_counts(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "b.js", "language": "javascript", "lines": 20, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "c.py", "language": "python", "lines": 30, "functions": [], "classes": [], "complexity": {}}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
import json
|
||||
parsed = json.loads(output)
|
||||
assert parsed["summary"]["languages"]["python"] == 2
|
||||
assert parsed["summary"]["languages"]["javascript"] == 1
|
||||
168
tests/unit/test_language_detector.py
Normal file
168
tests/unit/test_language_detector.py
Normal file
@@ -0,0 +1,168 @@
|
||||
"""Unit tests for language detection module."""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from codesnap.core.language_detector import (
|
||||
EXTENSION_TO_LANGUAGE,
|
||||
detect_language,
|
||||
detect_language_by_extension,
|
||||
detect_language_by_shebang,
|
||||
get_language_info,
|
||||
get_supported_extensions,
|
||||
get_supported_languages,
|
||||
)
|
||||
|
||||
|
||||
class TestDetectLanguageByExtension:
|
||||
"""Tests for extension-based language detection."""
|
||||
|
||||
def test_python_extension_py(self):
|
||||
assert detect_language_by_extension(Path("test.py")) == "python"
|
||||
|
||||
def test_python_extension_pyi(self):
|
||||
assert detect_language_by_extension(Path("test.pyi")) == "python"
|
||||
|
||||
def test_javascript_extension_js(self):
|
||||
assert detect_language_by_extension(Path("test.js")) == "javascript"
|
||||
|
||||
def test_typescript_extension_ts(self):
|
||||
assert detect_language_by_extension(Path("test.ts")) == "typescript"
|
||||
|
||||
def test_go_extension(self):
|
||||
assert detect_language_by_extension(Path("main.go")) == "go"
|
||||
|
||||
def test_rust_extension(self):
|
||||
assert detect_language_by_extension(Path("main.rs")) == "rust"
|
||||
|
||||
def test_java_extension(self):
|
||||
assert detect_language_by_extension(Path("Main.java")) == "java"
|
||||
|
||||
def test_cpp_extension(self):
|
||||
assert detect_language_by_extension(Path("test.cpp")) == "cpp"
|
||||
assert detect_language_by_extension(Path("test.hpp")) == "cpp"
|
||||
|
||||
def test_ruby_extension(self):
|
||||
assert detect_language_by_extension(Path("script.rb")) == "ruby"
|
||||
|
||||
def test_php_extension(self):
|
||||
assert detect_language_by_extension(Path("script.php")) == "php"
|
||||
|
||||
def test_unknown_extension(self):
|
||||
assert detect_language_by_extension(Path("test.xyz")) is None
|
||||
|
||||
def test_case_insensitive(self):
|
||||
assert detect_language_by_extension(Path("test.PY")) == "python"
|
||||
assert detect_language_by_extension(Path("test.JS")) == "javascript"
|
||||
|
||||
|
||||
class TestDetectLanguageByShebang:
|
||||
"""Tests for shebang-based language detection."""
|
||||
|
||||
def test_python_shebang(self):
|
||||
content = "#!/usr/bin/env python3\nprint('hello')"
|
||||
assert detect_language_by_shebang(content) == "python"
|
||||
|
||||
def test_python_shebang_alt(self):
|
||||
content = "#!/usr/bin/python\nprint('hello')"
|
||||
assert detect_language_by_shebang(content) == "python"
|
||||
|
||||
def test_node_shebang(self):
|
||||
content = "#!/usr/bin/env node\nconsole.log('hello')"
|
||||
assert detect_language_by_shebang(content) == "javascript"
|
||||
|
||||
def test_ruby_shebang(self):
|
||||
content = "#!/usr/bin/env ruby\nputs 'hello'"
|
||||
assert detect_language_by_shebang(content) == "ruby"
|
||||
|
||||
def test_php_shebang(self):
|
||||
content = "#!/usr/bin/env php\necho 'hello';"
|
||||
assert detect_language_by_shebang(content) == "php"
|
||||
|
||||
def test_no_shebang(self):
|
||||
content = "print('hello')"
|
||||
assert detect_language_by_shebang(content) is None
|
||||
|
||||
def test_empty_content(self):
|
||||
assert detect_language_by_shebang("") is None
|
||||
|
||||
|
||||
class TestDetectLanguage:
|
||||
"""Tests for combined language detection."""
|
||||
|
||||
def test_detection_by_extension(self):
|
||||
assert detect_language(Path("test.py")) == "python"
|
||||
assert detect_language(Path("test.js")) == "javascript"
|
||||
|
||||
def test_detection_fallback_to_shebang(self):
|
||||
file_path = Path("script")
|
||||
assert detect_language(file_path, "#!/usr/bin/env python") == "python"
|
||||
assert detect_language(file_path, "#!/usr/bin/env node") == "javascript"
|
||||
|
||||
def test_unknown_file_no_content(self):
|
||||
assert detect_language(Path("unknown.xyz")) is None
|
||||
|
||||
|
||||
class TestGetLanguageInfo:
|
||||
"""Tests for language info retrieval."""
|
||||
|
||||
def test_get_python_info(self):
|
||||
info = get_language_info("python")
|
||||
assert info is not None
|
||||
assert info.name == "python"
|
||||
assert ".py" in info.extensions
|
||||
|
||||
def test_get_unknown_language(self):
|
||||
info = get_language_info("unknown")
|
||||
assert info is None
|
||||
|
||||
|
||||
class TestGetSupportedExtensions:
|
||||
"""Tests for supported extensions."""
|
||||
|
||||
def test_returns_set(self):
|
||||
extensions = get_supported_extensions()
|
||||
assert isinstance(extensions, set)
|
||||
|
||||
def test_includes_common_extensions(self):
|
||||
extensions = get_supported_extensions()
|
||||
assert ".py" in extensions
|
||||
assert ".js" in extensions
|
||||
assert ".ts" in extensions
|
||||
assert ".go" in extensions
|
||||
|
||||
|
||||
class TestGetSupportedLanguages:
|
||||
"""Tests for supported programming languages."""
|
||||
|
||||
def test_returns_list(self):
|
||||
languages = get_supported_languages()
|
||||
assert isinstance(languages, list)
|
||||
|
||||
def test_includes_main_languages(self):
|
||||
languages = get_supported_languages()
|
||||
assert "python" in languages
|
||||
assert "javascript" in languages
|
||||
assert "typescript" in languages
|
||||
assert "go" in languages
|
||||
assert "rust" in languages
|
||||
assert "java" in languages
|
||||
|
||||
def test_excludes_config_formats(self):
|
||||
languages = get_supported_languages()
|
||||
assert "json" not in languages
|
||||
assert "yaml" not in languages
|
||||
assert "markdown" not in languages
|
||||
|
||||
|
||||
class TestExtensionToLanguage:
|
||||
"""Tests for extension to language mapping."""
|
||||
|
||||
def test_mapping_completeness(self):
|
||||
for _ext, lang in EXTENSION_TO_LANGUAGE.items():
|
||||
assert lang in ["python", "javascript", "typescript", "go", "rust",
|
||||
"java", "c", "cpp", "ruby", "php", "shell",
|
||||
"json", "yaml", "markdown"]
|
||||
|
||||
def test_no_duplicate_extensions(self):
|
||||
extensions = list(EXTENSION_TO_LANGUAGE.keys())
|
||||
assert len(extensions) == len(set(extensions))
|
||||
112
tests/unit/test_llm_formatter.py
Normal file
112
tests/unit/test_llm_formatter.py
Normal file
@@ -0,0 +1,112 @@
|
||||
from codesnap.output.llm_formatter import LLMFormatter
|
||||
|
||||
|
||||
class TestLLMFormatter:
|
||||
def setup_method(self) -> None:
|
||||
self.formatter = LLMFormatter(max_tokens=1000)
|
||||
|
||||
def test_format_valid_result(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{
|
||||
"file": "test.py",
|
||||
"language": "python",
|
||||
"lines": 50,
|
||||
"functions": [{"name": "test_func", "start_line": 1, "end_line": 10, "parameters": [], "return_type": "str"}],
|
||||
"classes": [],
|
||||
"complexity": {"score": 5, "rating": "low"}
|
||||
}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "## Codebase Summary" in output
|
||||
assert "### Key Files" in output
|
||||
assert "### Classes and Functions" in output
|
||||
assert "### Dependencies" in output
|
||||
|
||||
def test_respects_token_limit(self) -> None:
|
||||
result = {
|
||||
"files": [],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
max_chars = 1000 * 4
|
||||
assert len(output) <= max_chars + 100
|
||||
|
||||
def test_includes_high_level_summary(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{"file": "a.py", "language": "python", "lines": 50, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "b.py", "language": "python", "lines": 30, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "c.js", "language": "javascript", "lines": 20, "functions": [], "classes": [], "complexity": {}}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "python" in output.lower()
|
||||
assert "3 files" in output or "files" in output
|
||||
|
||||
def test_compresses_detailed_file_list(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{"file": f"file{i}.py", "language": "python", "lines": 10,
|
||||
"functions": [{"name": f"func{i}a"}, {"name": f"func{i}b"}, {"name": f"func{i}c"}],
|
||||
"classes": [], "complexity": {}}
|
||||
for i in range(10)
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "Detailed File List (compressed)" in output
|
||||
|
||||
def test_warns_about_cycles(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "b.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 2,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 1,
|
||||
"cycle_details": [["a.py", "b.py", "a.py"]],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "circular" in output.lower() or "cycle" in output.lower()
|
||||
117
tests/unit/test_markdown_formatter.py
Normal file
117
tests/unit/test_markdown_formatter.py
Normal file
@@ -0,0 +1,117 @@
|
||||
from codesnap.output.markdown_formatter import MarkdownFormatter
|
||||
|
||||
|
||||
class TestMarkdownFormatter:
|
||||
def setup_method(self) -> None:
|
||||
self.formatter = MarkdownFormatter()
|
||||
|
||||
def test_format_valid_result(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{
|
||||
"file": "test.py",
|
||||
"language": "python",
|
||||
"lines": 50,
|
||||
"functions": [{"name": "test_func", "start_line": 1, "end_line": 10, "parameters": [], "return_type": "str"}],
|
||||
"classes": [],
|
||||
"complexity": {"score": 5, "rating": "low"}
|
||||
}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "# CodeSnap Analysis Report" in output
|
||||
assert "## Overview" in output
|
||||
assert "## File Structure" in output
|
||||
assert "## Key Functions" in output
|
||||
assert "## Dependencies" in output
|
||||
assert "## Complexity Metrics" in output
|
||||
|
||||
def test_format_empty_result(self) -> None:
|
||||
result = {
|
||||
"files": [],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "Total Files" in output
|
||||
|
||||
def test_includes_language_breakdown(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "b.js", "language": "javascript", "lines": 20, "functions": [], "classes": [], "complexity": {}}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "python: 1" in output or "python: 2" in output
|
||||
assert "javascript:" in output
|
||||
|
||||
def test_shows_circular_dependencies(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
|
||||
{"file": "b.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 2,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 1,
|
||||
"cycle_details": [["a.py", "b.py", "a.py"]],
|
||||
"orphaned_details": [],
|
||||
"edges": [{"from": "a.py", "to": "b.py"}, {"from": "b.py", "to": "a.py"}],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "Circular Dependencies Detected" in output
|
||||
|
||||
def test_shows_high_complexity_files(self) -> None:
|
||||
result = {
|
||||
"files": [
|
||||
{
|
||||
"file": "complex.py",
|
||||
"language": "python",
|
||||
"lines": 100,
|
||||
"functions": [],
|
||||
"classes": [],
|
||||
"complexity": {"score": 55, "rating": "high"}
|
||||
}
|
||||
],
|
||||
"dependency_graph": {
|
||||
"total_dependencies": 0,
|
||||
"orphaned_files": 0,
|
||||
"cycles_detected": 0,
|
||||
"cycle_details": [],
|
||||
"orphaned_details": [],
|
||||
"edges": [],
|
||||
"statistics": {}
|
||||
}
|
||||
}
|
||||
output = self.formatter.format(result)
|
||||
assert "High Complexity Files" in output
|
||||
assert "complex.py" in output
|
||||
Reference in New Issue
Block a user